drivers/md/bcache/bcache.h

471

struct journal_device journal;

drivers/md/bcache/bcache.h

702

struct journal journal;

drivers/md/bcache/btree.c

287

if (w->journal) {

drivers/md/bcache/btree.c

288

atomic_dec_bug(w->journal);

drivers/md/bcache/btree.c

289

__closure_wake_up(&b->c->journal.wait);

drivers/md/bcache/btree.c

293

w->journal = NULL;

drivers/md/bcache/btree.c

496

if (w->journal &&

drivers/md/bcache/btree.c

497

journal_pin_cmp(b->c, w->journal, journal_ref)) {

drivers/md/bcache/btree.c

498

atomic_dec_bug(w->journal);

drivers/md/bcache/btree.c

499

w->journal = NULL;

drivers/md/bcache/btree.c

502

if (!w->journal) {

drivers/md/bcache/btree.c

503

w->journal = journal_ref;

drivers/md/bcache/btree.c

504

atomic_inc(w->journal);

drivers/md/bcache/btree.h

106

atomic_t *journal;

drivers/md/bcache/journal.c

183

struct journal_device *ja = &ca->journal;

drivers/md/bcache/journal.c

284

c->journal.seq = list_entry(list->prev,

drivers/md/bcache/journal.c

297

struct journal *j = &c->journal;

drivers/md/bcache/journal.c

38

struct journal_device *ja = &ca->journal;

drivers/md/bcache/journal.c

393

void bch_journal_space_reserve(struct journal *j)

drivers/md/bcache/journal.c

408

if (c->journal.btree_flushing)

drivers/md/bcache/journal.c

411

spin_lock(&c->journal.flush_write_lock);

drivers/md/bcache/journal.c

412

if (c->journal.btree_flushing) {

drivers/md/bcache/journal.c

413

spin_unlock(&c->journal.flush_write_lock);

drivers/md/bcache/journal.c

416

c->journal.btree_flushing = true;

drivers/md/bcache/journal.c

417

spin_unlock(&c->journal.flush_write_lock);

drivers/md/bcache/journal.c

42

struct jset *j, *data = ca->set->journal.w[0].data;

drivers/md/bcache/journal.c

420

spin_lock(&c->journal.lock);

drivers/md/bcache/journal.c

421

fifo_front_p = &fifo_front(&c->journal.pin);

drivers/md/bcache/journal.c

428

spin_unlock(&c->journal.lock);

drivers/md/bcache/journal.c

431

spin_unlock(&c->journal.lock);

drivers/md/bcache/journal.c

433

mask = c->journal.pin.mask;

drivers/md/bcache/journal.c

446

now_fifo_front_p = &fifo_front(&c->journal.pin);

drivers/md/bcache/journal.c

473

if (!btree_current_write(b)->journal) {

drivers/md/bcache/journal.c

491

if (((btree_current_write(b)->journal - fifo_front_p) &

drivers/md/bcache/journal.c

528

if (!btree_current_write(b)->journal) {

drivers/md/bcache/journal.c

548

spin_lock(&c->journal.flush_write_lock);

drivers/md/bcache/journal.c

549

c->journal.btree_flushing = false;

drivers/md/bcache/journal.c

550

spin_unlock(&c->journal.flush_write_lock);

drivers/md/bcache/journal.c

557

struct journal *j = &c->journal;

drivers/md/bcache/journal.c

559

struct journal_device *ja = &c->cache->journal;

drivers/md/bcache/journal.c

576

struct bkey *k = &c->journal.key;

drivers/md/bcache/journal.c

579

struct journal_device *ja = &ca->journal;

drivers/md/bcache/journal.c

584

while (!atomic_read(&fifo_front(&c->journal.pin)))

drivers/md/bcache/journal.c

585

fifo_pop(&c->journal.pin, p);

drivers/md/bcache/journal.c

587

last_seq = last_seq(&c->journal);

drivers/md/bcache/journal.c

596

if (c->journal.blocks_free)

drivers/md/bcache/journal.c

610

c->journal.blocks_free = ca->sb.bucket_size >> c->block_bits;

drivers/md/bcache/journal.c

613

if (!journal_full(&c->journal))

drivers/md/bcache/journal.c

614

__closure_wake_up(&c->journal.wait);

drivers/md/bcache/journal.c

617

void bch_journal_next(struct journal *j)

drivers/md/bcache/journal.c

646

closure_put(&w->c->journal.io);

drivers/md/bcache/journal.c

653

closure_type(j, struct journal, io);

drivers/md/bcache/journal.c

663

__releases(&c->journal.lock)

drivers/md/bcache/journal.c

665

closure_type(c, struct cache_set, journal.io);

drivers/md/bcache/journal.c

667

c->journal.io_in_flight = 0;

drivers/md/bcache/journal.c

668

spin_unlock(&c->journal.lock);

drivers/md/bcache/journal.c

672

__releases(c->journal.lock)

drivers/md/bcache/journal.c

674

closure_type(c, struct cache_set, journal.io);

drivers/md/bcache/journal.c

676

struct journal_write *w = c->journal.cur;

drivers/md/bcache/journal.c

677

struct bkey *k = &c->journal.key;

drivers/md/bcache/journal.c

689

} else if (journal_full(&c->journal)) {

drivers/md/bcache/journal.c

691

spin_unlock(&c->journal.lock);

drivers/md/bcache/journal.c

698

c->journal.blocks_free -= set_blocks(w->data, block_bytes(ca));

drivers/md/bcache/journal.c

708

w->data->last_seq = last_seq(&c->journal);

drivers/md/bcache/journal.c

713

bio = &ca->journal.bio;

drivers/md/bcache/journal.c

731

ca->journal.seq[ca->journal.cur_idx] = w->data->seq;

drivers/md/bcache/journal.c

737

atomic_dec_bug(&fifo_back(&c->journal.pin));

drivers/md/bcache/journal.c

738

bch_journal_next(&c->journal);

drivers/md/bcache/journal.c

741

spin_unlock(&c->journal.lock);

drivers/md/bcache/journal.c

751

closure_type(c, struct cache_set, journal.io);

drivers/md/bcache/journal.c

753

spin_lock(&c->journal.lock);

drivers/md/bcache/journal.c

758

__releases(c->journal.lock)

drivers/md/bcache/journal.c

760

struct closure *cl = &c->journal.io;

drivers/md/bcache/journal.c

761

struct journal_write *w = c->journal.cur;

drivers/md/bcache/journal.c

765

if (!c->journal.io_in_flight) {

drivers/md/bcache/journal.c

766

c->journal.io_in_flight = 1;

drivers/md/bcache/journal.c

769

spin_unlock(&c->journal.lock);

drivers/md/bcache/journal.c

775

__acquires(&c->journal.lock)

drivers/md/bcache/journal.c

784

spin_lock(&c->journal.lock);

drivers/md/bcache/journal.c

787

struct journal_write *w = c->journal.cur;

drivers/md/bcache/journal.c

793

c->journal.blocks_free * ca->sb.block_size,

drivers/md/bcache/journal.c

798

closure_wait(&c->journal.wait, &cl);

drivers/md/bcache/journal.c

800

if (!journal_full(&c->journal)) {

drivers/md/bcache/journal.c

818

spin_unlock(&c->journal.lock);

drivers/md/bcache/journal.c

824

spin_lock(&c->journal.lock);

drivers/md/bcache/journal.c

833

journal.work);

drivers/md/bcache/journal.c

834

spin_lock(&c->journal.lock);

drivers/md/bcache/journal.c

835

if (c->journal.cur->dirty)

drivers/md/bcache/journal.c

838

spin_unlock(&c->journal.lock);

drivers/md/bcache/journal.c

866

ret = &fifo_back(&c->journal.pin);

drivers/md/bcache/journal.c

874

queue_delayed_work(bch_flush_wq, &c->journal.work,

drivers/md/bcache/journal.c

876

spin_unlock(&c->journal.lock);

drivers/md/bcache/journal.c

878

spin_unlock(&c->journal.lock);

drivers/md/bcache/journal.c

899

free_pages((unsigned long) c->journal.w[1].data, JSET_BITS);

drivers/md/bcache/journal.c

900

free_pages((unsigned long) c->journal.w[0].data, JSET_BITS);

drivers/md/bcache/journal.c

901

free_fifo(&c->journal.pin);

drivers/md/bcache/journal.c

906

struct journal *j = &c->journal;

drivers/md/bcache/journal.h

150

(fifo_idx(&(c)->journal.pin, (l)) > fifo_idx(&(c)->journal.pin, (r)))

drivers/md/bcache/journal.h

165

void bch_journal_next(struct journal *j);

drivers/md/bcache/journal.h

173

void bch_journal_space_reserve(struct journal *j);

drivers/md/bcache/super.c

1759

if (c->journal.cur) {

drivers/md/bcache/super.c

1760

cancel_delayed_work_sync(&c->journal.work);

drivers/md/bcache/super.c

1762

c->journal.work.work.func(&c->journal.work.work);

drivers/md/bcache/super.c

1992

LIST_HEAD(journal);

drivers/md/bcache/super.c

2005

if (bch_journal_read(c, &journal))

drivers/md/bcache/super.c

2011

if (list_empty(&journal))

drivers/md/bcache/super.c

2014

j = &list_entry(journal.prev, struct journal_replay, list)->j;

drivers/md/bcache/super.c

2050

bch_journal_mark(c, &journal);

drivers/md/bcache/super.c

2059

bch_journal_next(&c->journal);

drivers/md/bcache/super.c

2079

if (bch_journal_replay(c, &journal))

drivers/md/bcache/super.c

2125

bch_journal_next(&c->journal);

drivers/md/bcache/super.c

2145

bch_journal_space_reserve(&c->journal);

drivers/md/bcache/super.c

2149

while (!list_empty(&journal)) {

drivers/md/bcache/super.c

2150

l = list_first_entry(&journal, struct journal_replay, list);

drivers/md/bcache/super.c

2255

bio_init_inline(&ca->journal.bio, NULL, 8, 0);

drivers/md/bcache/sysfs.c

783

sysfs_print(active_journal_entries, fifo_used(&c->journal.pin));

drivers/md/dm-integrity.c

1070

io_req.mem.ptr.pl = &ic->journal[pl_index];

drivers/md/dm-integrity.c

1191

io_req.mem.ptr.pl = &ic->journal[pl_index];

drivers/md/dm-integrity.c

184

struct page_list *journal;

drivers/md/dm-integrity.c

3436

block_bitmap_op(ic, ic->journal, dio->range.logical_sector,

drivers/md/dm-integrity.c

3488

block_bitmap_op(ic, ic->journal, 0, limit, BITMAP_OP_CLEAR);

drivers/md/dm-integrity.c

3578

DEBUG_bytes(lowmem_page_address(ic->journal[0].page), 64, "decrypted journal");

drivers/md/dm-integrity.c

3812

block_bitmap_op(ic, ic->journal, old_provided_data_sectors,

drivers/md/dm-integrity.c

3831

block_bitmap_copy(ic, ic->recalc_bitmap, ic->journal);

drivers/md/dm-integrity.c

3832

block_bitmap_copy(ic, ic->may_write_bitmap, ic->journal);

drivers/md/dm-integrity.c

3833

if (!block_bitmap_op(ic, ic->journal, 0, ic->provided_data_sectors,

drivers/md/dm-integrity.c

3844

block_bitmap_op(ic, ic->journal, 0, ic->provided_data_sectors, BITMAP_OP_SET);

drivers/md/dm-integrity.c

3852

block_bitmap_op(ic, ic->journal, 0, ic->provided_data_sectors, BITMAP_OP_TEST_ALL_CLEAR)) ||

drivers/md/dm-integrity.c

3877

block_bitmap_op(ic, ic->journal, 0, ic->provided_data_sectors, BITMAP_OP_CLEAR);

drivers/md/dm-integrity.c

3882

block_bitmap_op(ic, ic->journal, le64_to_cpu(ic->sb->recalc_sector),

drivers/md/dm-integrity.c

4431

ic->journal = dm_integrity_alloc_page_list(ic->journal_pages);

drivers/md/dm-integrity.c

4432

if (!ic->journal) {

drivers/md/dm-integrity.c

4550

ic->journal_scatterlist = dm_integrity_alloc_journal_scatterlist(ic, ic->journal);

drivers/md/dm-integrity.c

5301

bbs->bitmap = lowmem_page_address(ic->journal[pl_index].page) + pl_offset;

drivers/md/dm-integrity.c

5392

dm_integrity_free_page_list(ic->journal);

drivers/md/dm-integrity.c

759

return access_page_list(ic, ic->journal, section, offset, NULL);

drivers/md/dm-integrity.c

899

source_pl = ic->journal;

drivers/md/dm-integrity.c

903

target_pl = ic->journal;

drivers/md/dm-vdo/block-map.c

1077

vdo_release_recovery_journal_block_reference(cache->zone->block_map->journal,

drivers/md/dm-vdo/block-map.c

1579

vdo_release_recovery_journal_block_reference(zone->block_map->journal,

drivers/md/dm-vdo/block-map.c

2877

struct vdo *vdo, struct recovery_journal *journal,

drivers/md/dm-vdo/block-map.c

2901

map->journal = journal;

drivers/md/dm-vdo/block-map.c

2922

vdo_get_recovery_journal_thread_id(journal),

drivers/md/dm-vdo/block-map.c

2947

struct recovery_journal *journal)

drivers/md/dm-vdo/block-map.c

2951

map->current_era_point = vdo_get_recovery_journal_current_sequence_number(journal);

drivers/md/dm-vdo/block-map.c

3218

struct recovery_journal *journal = block_map->journal;

drivers/md/dm-vdo/block-map.c

3231

vdo_acquire_recovery_journal_block_reference(journal, new_locked,

drivers/md/dm-vdo/block-map.c

3236

vdo_release_recovery_journal_block_reference(journal, old_locked,

drivers/md/dm-vdo/block-map.c

3248

vdo_release_journal_entry_lock(journal, new_locked);

drivers/md/dm-vdo/block-map.h

269

struct recovery_journal *journal;

drivers/md/dm-vdo/block-map.h

335

struct recovery_journal *journal, nonce_t nonce,

drivers/md/dm-vdo/block-map.h

356

struct recovery_journal *journal);

drivers/md/dm-vdo/message-stats.c

356

write_recovery_journal_statistics("journal : ", &stats->journal, ", ",

drivers/md/dm-vdo/recovery-journal.c

1002

static bool prepare_to_assign_entry(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

1004

if (journal->available_space == 0)

drivers/md/dm-vdo/recovery-journal.c

1007

if (is_block_full(journal->active_block) && !advance_tail(journal))

drivers/md/dm-vdo/recovery-journal.c

101

static atomic_t *get_decrement_counter(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

1010

if (!is_block_empty(journal->active_block))

drivers/md/dm-vdo/recovery-journal.c

1013

if ((journal->tail - get_recovery_journal_head(journal)) > journal->size) {

drivers/md/dm-vdo/recovery-journal.c

1015

journal->events.disk_full++;

drivers/md/dm-vdo/recovery-journal.c

1025

initialize_lock_count(journal);

drivers/md/dm-vdo/recovery-journal.c

1029

static void write_blocks(struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.c

104

return &journal->lock_counter.journal_decrement_counts[lock_number];

drivers/md/dm-vdo/recovery-journal.c

1040

static void schedule_block_write(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

1044

vdo_waitq_enqueue_waiter(&journal->pending_writes, &block->write_waiter);

drivers/md/dm-vdo/recovery-journal.c

1057

vdo_release_recovery_journal_block_reference(block->journal,

drivers/md/dm-vdo/recovery-journal.c

1062

static void update_usages(struct recovery_journal *journal, struct data_vio *data_vio)

drivers/md/dm-vdo/recovery-journal.c

1065

journal->block_map_data_blocks++;

drivers/md/dm-vdo/recovery-journal.c

1070

journal->logical_blocks_used++;

drivers/md/dm-vdo/recovery-journal.c

1073

journal->logical_blocks_used--;

drivers/md/dm-vdo/recovery-journal.c

1087

struct recovery_journal *journal = block->journal;

drivers/md/dm-vdo/recovery-journal.c

1095

update_usages(journal, data_vio);

drivers/md/dm-vdo/recovery-journal.c

1096

journal->available_space--;

drivers/md/dm-vdo/recovery-journal.c

1099

journal->events.blocks.started++;

drivers/md/dm-vdo/recovery-journal.c

1104

journal->events.entries.started++;

drivers/md/dm-vdo/recovery-journal.c

1111

schedule_block_write(journal, block);

drivers/md/dm-vdo/recovery-journal.c

1115

check_slab_journal_commit_threshold(journal);

drivers/md/dm-vdo/recovery-journal.c

1118

static void assign_entries(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

1120

if (journal->adding_entries) {

drivers/md/dm-vdo/recovery-journal.c

1125

journal->adding_entries = true;

drivers/md/dm-vdo/recovery-journal.c

1126

while (vdo_waitq_has_waiters(&journal->entry_waiters) &&

drivers/md/dm-vdo/recovery-journal.c

1127

prepare_to_assign_entry(journal)) {

drivers/md/dm-vdo/recovery-journal.c

1128

vdo_waitq_notify_next_waiter(&journal->entry_waiters,

drivers/md/dm-vdo/recovery-journal.c

1129

assign_entry, journal->active_block);

drivers/md/dm-vdo/recovery-journal.c

1133

write_blocks(journal);

drivers/md/dm-vdo/recovery-journal.c

1134

journal->adding_entries = false;

drivers/md/dm-vdo/recovery-journal.c

114

static bool is_journal_zone_locked(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

1144

struct recovery_journal *journal = block->journal;

drivers/md/dm-vdo/recovery-journal.c

1147

list_move_tail(&block->list_node, &journal->free_tail_blocks);

drivers/md/dm-vdo/recovery-journal.c

1150

for (i = block->entry_count; i < journal->entries_per_block; i++)

drivers/md/dm-vdo/recovery-journal.c

1160

if (block == journal->active_block)

drivers/md/dm-vdo/recovery-journal.c

1161

journal->active_block = NULL;

drivers/md/dm-vdo/recovery-journal.c

117

u16 journal_value = *get_counter(journal, lock_number, VDO_ZONE_TYPE_JOURNAL, 0);

drivers/md/dm-vdo/recovery-journal.c

1175

struct recovery_journal *journal = context;

drivers/md/dm-vdo/recovery-journal.c

1176

int result = (is_read_only(journal) ? VDO_READ_ONLY : VDO_SUCCESS);

drivers/md/dm-vdo/recovery-journal.c

1179

VDO_ASSERT_LOG_ONLY(vdo_before_journal_point(&journal->commit_point,

drivers/md/dm-vdo/recovery-journal.c

118

u32 decrements = atomic_read(get_decrement_counter(journal, lock_number));

drivers/md/dm-vdo/recovery-journal.c

1182

(unsigned long long) journal->commit_point.sequence_number,

drivers/md/dm-vdo/recovery-journal.c

1183

journal->commit_point.entry_count,

drivers/md/dm-vdo/recovery-journal.c

1187

journal->commit_point = data_vio->recovery_journal_point;

drivers/md/dm-vdo/recovery-journal.c

1210

static void notify_commit_waiters(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

1214

list_for_each_entry(block, &journal->active_tail_blocks, list_node) {

drivers/md/dm-vdo/recovery-journal.c

1219

continue_committed_waiter, journal);

drivers/md/dm-vdo/recovery-journal.c

1220

if (is_read_only(journal)) {

drivers/md/dm-vdo/recovery-journal.c

1223

journal);

drivers/md/dm-vdo/recovery-journal.c

1235

static void recycle_journal_blocks(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

1239

list_for_each_entry_safe(block, tmp, &journal->active_tail_blocks, list_node) {

drivers/md/dm-vdo/recovery-journal.c

1245

if (!is_read_only(journal) &&

drivers/md/dm-vdo/recovery-journal.c

1268

struct recovery_journal *journal = block->journal;

drivers/md/dm-vdo/recovery-journal.c

1271

assert_on_journal_thread(journal, __func__);

drivers/md/dm-vdo/recovery-journal.c

1273

journal->pending_write_count -= 1;

drivers/md/dm-vdo/recovery-journal.c

1274

journal->events.blocks.committed += 1;

drivers/md/dm-vdo/recovery-journal.c

1275

journal->events.entries.committed += block->entries_in_commit;

drivers/md/dm-vdo/recovery-journal.c

1281

if (block->sequence_number > journal->last_write_acknowledged)

drivers/md/dm-vdo/recovery-journal.c

1282

journal->last_write_acknowledged = block->sequence_number;

drivers/md/dm-vdo/recovery-journal.c

1284

last_active_block = get_journal_block(&journal->active_tail_blocks);

drivers/md/dm-vdo/recovery-journal.c

1288

notify_commit_waiters(journal);

drivers/md/dm-vdo/recovery-journal.c

1295

schedule_block_write(journal, block);

drivers/md/dm-vdo/recovery-journal.c

1297

recycle_journal_blocks(journal);

drivers/md/dm-vdo/recovery-journal.c

1298

write_blocks(journal);

drivers/md/dm-vdo/recovery-journal.c

1300

check_for_drain_complete(journal);

drivers/md/dm-vdo/recovery-journal.c

1306

struct recovery_journal *journal = block->journal;

drivers/md/dm-vdo/recovery-journal.c

1312

enter_journal_read_only_mode(journal, completion->result);

drivers/md/dm-vdo/recovery-journal.c

1320

struct recovery_journal *journal = block->journal;

drivers/md/dm-vdo/recovery-journal.c

1322

continue_vio_after_io(vio, complete_write, journal->thread_id);

drivers/md/dm-vdo/recovery-journal.c

1375

struct recovery_journal *journal = block->journal;

drivers/md/dm-vdo/recovery-journal.c

1379

is_read_only(journal))

drivers/md/dm-vdo/recovery-journal.c

138

void vdo_release_recovery_journal_block_reference(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

1385

journal->pending_write_count += 1;

drivers/md/dm-vdo/recovery-journal.c

1386

journal->events.blocks.written += 1;

drivers/md/dm-vdo/recovery-journal.c

1387

journal->events.entries.written += block->entries_in_commit;

drivers/md/dm-vdo/recovery-journal.c

1389

header->block_map_head = __cpu_to_le64(journal->block_map_head);

drivers/md/dm-vdo/recovery-journal.c

1390

header->slab_journal_head = __cpu_to_le64(journal->slab_journal_head);

drivers/md/dm-vdo/recovery-journal.c

1400

vdo_submit_metadata_vio(&block->vio, journal->origin + block->block_number,

drivers/md/dm-vdo/recovery-journal.c

1410

static void write_blocks(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

1412

assert_on_journal_thread(journal, __func__);

drivers/md/dm-vdo/recovery-journal.c

1422

if (journal->pending_write_count > 0)

drivers/md/dm-vdo/recovery-journal.c

1426

vdo_waitq_notify_all_waiters(&journal->pending_writes, write_block, NULL);

drivers/md/dm-vdo/recovery-journal.c

1432

if ((journal->pending_write_count == 0) && (journal->active_block != NULL))

drivers/md/dm-vdo/recovery-journal.c

1433

write_block(&journal->active_block->write_waiter, NULL);

drivers/md/dm-vdo/recovery-journal.c

1448

void vdo_add_recovery_journal_entry(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

1451

assert_on_journal_thread(journal, __func__);

drivers/md/dm-vdo/recovery-journal.c

1452

if (!vdo_is_state_normal(&journal->state)) {

drivers/md/dm-vdo/recovery-journal.c

1457

if (is_read_only(journal)) {

drivers/md/dm-vdo/recovery-journal.c

1465

vdo_advance_journal_point(&journal->append_point, journal->entries_per_block);

drivers/md/dm-vdo/recovery-journal.c

1466

vdo_waitq_enqueue_waiter(&journal->entry_waiters, &data_vio->waiter);

drivers/md/dm-vdo/recovery-journal.c

1467

assign_entries(journal);

drivers/md/dm-vdo/recovery-journal.c

1481

static bool is_lock_locked(struct recovery_journal *journal, block_count_t lock_number,

drivers/md/dm-vdo/recovery-journal.c

1487

if (is_journal_zone_locked(journal, lock_number))

drivers/md/dm-vdo/recovery-journal.c

1490

zone_count = get_zone_count_ptr(journal, lock_number, zone_type);

drivers/md/dm-vdo/recovery-journal.c

150

lock_number = vdo_get_recovery_journal_block_number(journal, sequence_number);

drivers/md/dm-vdo/recovery-journal.c

1501

static void reap_recovery_journal(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

1503

if (journal->reaping) {

drivers/md/dm-vdo/recovery-journal.c

151

current_value = get_counter(journal, lock_number, zone_type, zone_id);

drivers/md/dm-vdo/recovery-journal.c

1511

if (vdo_is_state_quiescent(&journal->state)) {

drivers/md/dm-vdo/recovery-journal.c

1520

while ((journal->block_map_reap_head < journal->last_write_acknowledged) &&

drivers/md/dm-vdo/recovery-journal.c

1521

!is_lock_locked(journal, journal->block_map_head_block_number,

drivers/md/dm-vdo/recovery-journal.c

1523

journal->block_map_reap_head++;

drivers/md/dm-vdo/recovery-journal.c

1524

if (++journal->block_map_head_block_number == journal->size)

drivers/md/dm-vdo/recovery-journal.c

1525

journal->block_map_head_block_number = 0;

drivers/md/dm-vdo/recovery-journal.c

1528

while ((journal->slab_journal_reap_head < journal->last_write_acknowledged) &&

drivers/md/dm-vdo/recovery-journal.c

1529

!is_lock_locked(journal, journal->slab_journal_head_block_number,

drivers/md/dm-vdo/recovery-journal.c

1531

journal->slab_journal_reap_head++;

drivers/md/dm-vdo/recovery-journal.c

1532

if (++journal->slab_journal_head_block_number == journal->size)

drivers/md/dm-vdo/recovery-journal.c

1533

journal->slab_journal_head_block_number = 0;

drivers/md/dm-vdo/recovery-journal.c

1536

if ((journal->block_map_reap_head == journal->block_map_head) &&

drivers/md/dm-vdo/recovery-journal.c

1537

(journal->slab_journal_reap_head == journal->slab_journal_head)) {

drivers/md/dm-vdo/recovery-journal.c

1547

journal->reaping = true;

drivers/md/dm-vdo/recovery-journal.c

1548

vdo_submit_flush_vio(journal->flush_vio, flush_endio, handle_flush_error);

drivers/md/dm-vdo/recovery-journal.c

1559

void vdo_acquire_recovery_journal_block_reference(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

1573

lock_number = vdo_get_recovery_journal_block_number(journal, sequence_number);

drivers/md/dm-vdo/recovery-journal.c

1574

current_value = get_counter(journal, lock_number, zone_type, zone_id);

drivers/md/dm-vdo/recovery-journal.c

158

if (is_journal_zone_locked(journal, lock_number))

drivers/md/dm-vdo/recovery-journal.c

1584

atomic_inc(get_zone_count_ptr(journal, lock_number, zone_type));

drivers/md/dm-vdo/recovery-journal.c

1598

void vdo_release_journal_entry_lock(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

1606

lock_number = vdo_get_recovery_journal_block_number(journal, sequence_number);

drivers/md/dm-vdo/recovery-journal.c

1612

atomic_inc(get_decrement_counter(journal, lock_number));

drivers/md/dm-vdo/recovery-journal.c

1631

void vdo_drain_recovery_journal(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

1635

assert_on_journal_thread(journal, __func__);

drivers/md/dm-vdo/recovery-journal.c

1636

vdo_start_draining(&journal->state, operation, parent, initiate_drain);

drivers/md/dm-vdo/recovery-journal.c

166

zone_count = get_zone_count_ptr(journal, lock_number, zone_type);

drivers/md/dm-vdo/recovery-journal.c

1667

void vdo_resume_recovery_journal(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

1672

assert_on_journal_thread(journal, __func__);

drivers/md/dm-vdo/recovery-journal.c

1673

saved = vdo_is_state_saved(&journal->state);

drivers/md/dm-vdo/recovery-journal.c

1674

vdo_set_completion_result(parent, vdo_resume_if_quiescent(&journal->state));

drivers/md/dm-vdo/recovery-journal.c

1675

if (is_read_only(journal)) {

drivers/md/dm-vdo/recovery-journal.c

1681

initialize_journal_state(journal);

drivers/md/dm-vdo/recovery-journal.c

1683

if (resume_lock_counter(&journal->lock_counter)) {

drivers/md/dm-vdo/recovery-journal.c

1685

reap_recovery_journal(journal);

drivers/md/dm-vdo/recovery-journal.c

1698

block_count_t vdo_get_recovery_journal_logical_blocks_used(const struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

1700

return journal->logical_blocks_used;

drivers/md/dm-vdo/recovery-journal.c

1710

vdo_get_recovery_journal_statistics(const struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

1712

return journal->events;

drivers/md/dm-vdo/recovery-journal.c

1733

void vdo_dump_recovery_journal_statistics(const struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

1736

struct recovery_journal_statistics stats = vdo_get_recovery_journal_statistics(journal);

drivers/md/dm-vdo/recovery-journal.c

1740

(unsigned long long) journal->block_map_head,

drivers/md/dm-vdo/recovery-journal.c

1741

(unsigned long long) journal->slab_journal_head,

drivers/md/dm-vdo/recovery-journal.c

1742

(unsigned long long) journal->last_write_acknowledged,

drivers/md/dm-vdo/recovery-journal.c

1743

(unsigned long long) journal->tail,

drivers/md/dm-vdo/recovery-journal.c

1744

(unsigned long long) journal->block_map_reap_head,

drivers/md/dm-vdo/recovery-journal.c

1745

(unsigned long long) journal->slab_journal_reap_head,

drivers/md/dm-vdo/recovery-journal.c

1748

vdo_waitq_num_waiters(&journal->entry_waiters));

drivers/md/dm-vdo/recovery-journal.c

1759

list_for_each_entry(block, &journal->active_tail_blocks, list_node)

drivers/md/dm-vdo/recovery-journal.c

177

prior_state = atomic_cmpxchg(&journal->lock_counter.state,

drivers/md/dm-vdo/recovery-journal.c

186

vdo_launch_completion(&journal->lock_counter.completion);

drivers/md/dm-vdo/recovery-journal.c

200

static struct recovery_journal_block * __must_check pop_free_list(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

204

if (list_empty(&journal->free_tail_blocks))

drivers/md/dm-vdo/recovery-journal.c

207

block = list_last_entry(&journal->free_tail_blocks,

drivers/md/dm-vdo/recovery-journal.c

246

return ((block == NULL) || (block->journal->entries_per_block == block->entry_count));

drivers/md/dm-vdo/recovery-journal.c

254

static void assert_on_journal_thread(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

257

VDO_ASSERT_LOG_ONLY((vdo_get_callback_thread_id() == journal->thread_id),

drivers/md/dm-vdo/recovery-journal.c

280

static inline bool has_block_waiters(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

282

struct recovery_journal_block *block = get_journal_block(&journal->active_tail_blocks);

drivers/md/dm-vdo/recovery-journal.c

293

static void recycle_journal_blocks(struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.c

295

static void notify_commit_waiters(struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.c

321

static inline bool is_read_only(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

323

return vdo_is_read_only(journal->flush_vio->completion.vdo);

drivers/md/dm-vdo/recovery-journal.c

330

static void check_for_drain_complete(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

334

if (is_read_only(journal)) {

drivers/md/dm-vdo/recovery-journal.c

341

notify_commit_waiters(journal);

drivers/md/dm-vdo/recovery-journal.c

342

recycle_journal_blocks(journal);

drivers/md/dm-vdo/recovery-journal.c

345

vdo_waitq_notify_all_waiters(&journal->entry_waiters,

drivers/md/dm-vdo/recovery-journal.c

349

if (!vdo_is_state_draining(&journal->state) ||

drivers/md/dm-vdo/recovery-journal.c

350

journal->reaping ||

drivers/md/dm-vdo/recovery-journal.c

351

has_block_waiters(journal) ||

drivers/md/dm-vdo/recovery-journal.c

352

vdo_waitq_has_waiters(&journal->entry_waiters) ||

drivers/md/dm-vdo/recovery-journal.c

353

!suspend_lock_counter(&journal->lock_counter))

drivers/md/dm-vdo/recovery-journal.c

356

if (vdo_is_state_saving(&journal->state)) {

drivers/md/dm-vdo/recovery-journal.c

357

if (journal->active_block != NULL) {

drivers/md/dm-vdo/recovery-journal.c

359

!is_block_dirty(journal->active_block)),

drivers/md/dm-vdo/recovery-journal.c

361

recycle_journal_block(journal->active_block);

drivers/md/dm-vdo/recovery-journal.c

364

VDO_ASSERT_LOG_ONLY(list_empty(&journal->active_tail_blocks),

drivers/md/dm-vdo/recovery-journal.c

368

vdo_finish_draining_with_result(&journal->state, result);

drivers/md/dm-vdo/recovery-journal.c

394

static void enter_journal_read_only_mode(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

397

vdo_enter_read_only_mode(journal->flush_vio->completion.vdo, error_code);

drivers/md/dm-vdo/recovery-journal.c

398

check_for_drain_complete(journal);

drivers/md/dm-vdo/recovery-journal.c

410

sequence_number_t vdo_get_recovery_journal_current_sequence_number(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

412

return journal->tail;

drivers/md/dm-vdo/recovery-journal.c

423

static inline sequence_number_t get_recovery_journal_head(const struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

425

return min(journal->block_map_head, journal->slab_journal_head);

drivers/md/dm-vdo/recovery-journal.c

444

static void check_slab_journal_commit_threshold(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

446

block_count_t current_length = journal->tail - journal->slab_journal_head;

drivers/md/dm-vdo/recovery-journal.c

448

if (current_length > journal->slab_journal_commit_threshold) {

drivers/md/dm-vdo/recovery-journal.c

449

journal->events.slab_journal_commits_requested++;

drivers/md/dm-vdo/recovery-journal.c

450

vdo_commit_oldest_slab_journal_tail_blocks(journal->depot,

drivers/md/dm-vdo/recovery-journal.c

451

journal->slab_journal_head);

drivers/md/dm-vdo/recovery-journal.c

455

static void reap_recovery_journal(struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.c

456

static void assign_entries(struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.c

462

static void finish_reaping(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

465

sequence_number_t old_head = get_recovery_journal_head(journal);

drivers/md/dm-vdo/recovery-journal.c

467

journal->block_map_head = journal->block_map_reap_head;

drivers/md/dm-vdo/recovery-journal.c

468

journal->slab_journal_head = journal->slab_journal_reap_head;

drivers/md/dm-vdo/recovery-journal.c

469

blocks_reaped = get_recovery_journal_head(journal) - old_head;

drivers/md/dm-vdo/recovery-journal.c

470

journal->available_space += blocks_reaped * journal->entries_per_block;

drivers/md/dm-vdo/recovery-journal.c

471

journal->reaping = false;

drivers/md/dm-vdo/recovery-journal.c

472

check_slab_journal_commit_threshold(journal);

drivers/md/dm-vdo/recovery-journal.c

473

assign_entries(journal);

drivers/md/dm-vdo/recovery-journal.c

474

check_for_drain_complete(journal);

drivers/md/dm-vdo/recovery-journal.c

485

struct recovery_journal *journal = completion->parent;

drivers/md/dm-vdo/recovery-journal.c

487

finish_reaping(journal);

drivers/md/dm-vdo/recovery-journal.c

490

reap_recovery_journal(journal);

drivers/md/dm-vdo/recovery-journal.c

499

struct recovery_journal *journal = completion->parent;

drivers/md/dm-vdo/recovery-journal.c

502

journal->reaping = false;

drivers/md/dm-vdo/recovery-journal.c

503

enter_journal_read_only_mode(journal, completion->result);

drivers/md/dm-vdo/recovery-journal.c

509

struct recovery_journal *journal = vio->completion.parent;

drivers/md/dm-vdo/recovery-journal.c

511

continue_vio_after_io(vio, complete_reaping, journal->thread_id);

drivers/md/dm-vdo/recovery-journal.c

519

static void initialize_journal_state(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

521

journal->append_point.sequence_number = journal->tail;

drivers/md/dm-vdo/recovery-journal.c

522

journal->last_write_acknowledged = journal->tail;

drivers/md/dm-vdo/recovery-journal.c

523

journal->block_map_head = journal->tail;

drivers/md/dm-vdo/recovery-journal.c

524

journal->slab_journal_head = journal->tail;

drivers/md/dm-vdo/recovery-journal.c

525

journal->block_map_reap_head = journal->tail;

drivers/md/dm-vdo/recovery-journal.c

526

journal->slab_journal_reap_head = journal->tail;

drivers/md/dm-vdo/recovery-journal.c

527

journal->block_map_head_block_number =

drivers/md/dm-vdo/recovery-journal.c

528

vdo_get_recovery_journal_block_number(journal, journal->block_map_head);

drivers/md/dm-vdo/recovery-journal.c

529

journal->slab_journal_head_block_number =

drivers/md/dm-vdo/recovery-journal.c

530

vdo_get_recovery_journal_block_number(journal,

drivers/md/dm-vdo/recovery-journal.c

531

journal->slab_journal_head);

drivers/md/dm-vdo/recovery-journal.c

532

journal->available_space =

drivers/md/dm-vdo/recovery-journal.c

533

(journal->entries_per_block * vdo_get_recovery_journal_length(journal->size));

drivers/md/dm-vdo/recovery-journal.c

560

struct recovery_journal *journal = (struct recovery_journal *) completion->parent;

drivers/md/dm-vdo/recovery-journal.c

566

atomic_set(&journal->lock_counter.state, LOCK_COUNTER_STATE_NOT_NOTIFYING);

drivers/md/dm-vdo/recovery-journal.c

568

if (vdo_is_state_quiescing(&journal->state)) {

drivers/md/dm-vdo/recovery-journal.c

573

check_for_drain_complete(journal);

drivers/md/dm-vdo/recovery-journal.c

577

reap_recovery_journal(journal);

drivers/md/dm-vdo/recovery-journal.c

578

check_slab_journal_commit_threshold(journal);

drivers/md/dm-vdo/recovery-journal.c

589

static int __must_check initialize_lock_counter(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

594

struct lock_counter *counter = &journal->lock_counter;

drivers/md/dm-vdo/recovery-journal.c

596

result = vdo_allocate(journal->size, __func__, &counter->journal_counters);

drivers/md/dm-vdo/recovery-journal.c

600

result = vdo_allocate(journal->size, __func__, &counter->journal_decrement_counts);

drivers/md/dm-vdo/recovery-journal.c

604

result = vdo_allocate(journal->size * config->logical_zone_count, __func__,

drivers/md/dm-vdo/recovery-journal.c

609

result = vdo_allocate(journal->size, __func__, &counter->logical_zone_counts);

drivers/md/dm-vdo/recovery-journal.c

613

result = vdo_allocate(journal->size * config->physical_zone_count, __func__,

drivers/md/dm-vdo/recovery-journal.c

618

result = vdo_allocate(journal->size, __func__, &counter->physical_zone_counts);

drivers/md/dm-vdo/recovery-journal.c

626

journal);

drivers/md/dm-vdo/recovery-journal.c

629

counter->locks = journal->size;

drivers/md/dm-vdo/recovery-journal.c

638

static void set_journal_tail(struct recovery_journal *journal, sequence_number_t tail)

drivers/md/dm-vdo/recovery-journal.c

642

enter_journal_read_only_mode(journal, VDO_JOURNAL_OVERFLOW);

drivers/md/dm-vdo/recovery-journal.c

644

journal->tail = tail;

drivers/md/dm-vdo/recovery-journal.c

655

static int initialize_recovery_block(struct vdo *vdo, struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

67

static inline atomic_t *get_zone_count_ptr(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

683

list_add_tail(&block->list_node, &journal->free_tail_blocks);

drivers/md/dm-vdo/recovery-journal.c

684

block->journal = journal;

drivers/md/dm-vdo/recovery-journal.c

708

struct recovery_journal *journal;

drivers/md/dm-vdo/recovery-journal.c

712

__func__, &journal);

drivers/md/dm-vdo/recovery-journal.c

716

INIT_LIST_HEAD(&journal->free_tail_blocks);

drivers/md/dm-vdo/recovery-journal.c

717

INIT_LIST_HEAD(&journal->active_tail_blocks);

drivers/md/dm-vdo/recovery-journal.c

718

vdo_waitq_init(&journal->pending_writes);

drivers/md/dm-vdo/recovery-journal.c

72

? &journal->lock_counter.logical_zone_counts[lock_number]

drivers/md/dm-vdo/recovery-journal.c

720

journal->thread_id = vdo->thread_config.journal_thread;

drivers/md/dm-vdo/recovery-journal.c

721

journal->origin = partition->offset;

drivers/md/dm-vdo/recovery-journal.c

722

journal->nonce = nonce;

drivers/md/dm-vdo/recovery-journal.c

723

journal->recovery_count = compute_recovery_count_byte(recovery_count);

drivers/md/dm-vdo/recovery-journal.c

724

journal->size = journal_size;

drivers/md/dm-vdo/recovery-journal.c

725

journal->slab_journal_commit_threshold = (journal_size * 2) / 3;

drivers/md/dm-vdo/recovery-journal.c

726

journal->logical_blocks_used = state.logical_blocks_used;

drivers/md/dm-vdo/recovery-journal.c

727

journal->block_map_data_blocks = state.block_map_data_blocks;

drivers/md/dm-vdo/recovery-journal.c

728

journal->entries_per_block = RECOVERY_JOURNAL_ENTRIES_PER_BLOCK;

drivers/md/dm-vdo/recovery-journal.c

729

set_journal_tail(journal, state.journal_start);

drivers/md/dm-vdo/recovery-journal.c

73

: &journal->lock_counter.physical_zone_counts[lock_number]);

drivers/md/dm-vdo/recovery-journal.c

730

initialize_journal_state(journal);

drivers/md/dm-vdo/recovery-journal.c

732

vdo_set_admin_state_code(&journal->state, VDO_ADMIN_STATE_SUSPENDED);

drivers/md/dm-vdo/recovery-journal.c

735

struct recovery_journal_block *block = &journal->blocks[i];

drivers/md/dm-vdo/recovery-journal.c

737

result = initialize_recovery_block(vdo, journal, block);

drivers/md/dm-vdo/recovery-journal.c

739

vdo_free_recovery_journal(journal);

drivers/md/dm-vdo/recovery-journal.c

744

result = initialize_lock_counter(journal, vdo);

drivers/md/dm-vdo/recovery-journal.c

746

vdo_free_recovery_journal(journal);

drivers/md/dm-vdo/recovery-journal.c

751

journal, NULL, &journal->flush_vio);

drivers/md/dm-vdo/recovery-journal.c

753

vdo_free_recovery_journal(journal);

drivers/md/dm-vdo/recovery-journal.c

757

result = vdo_register_read_only_listener(vdo, journal,

drivers/md/dm-vdo/recovery-journal.c

759

journal->thread_id);

drivers/md/dm-vdo/recovery-journal.c

761

vdo_free_recovery_journal(journal);

drivers/md/dm-vdo/recovery-journal.c

765

result = vdo_make_default_thread(vdo, journal->thread_id);

drivers/md/dm-vdo/recovery-journal.c

767

vdo_free_recovery_journal(journal);

drivers/md/dm-vdo/recovery-journal.c

771

journal->flush_vio->completion.callback_thread_id = journal->thread_id;

drivers/md/dm-vdo/recovery-journal.c

772

*journal_ptr = journal;

drivers/md/dm-vdo/recovery-journal.c

780

void vdo_free_recovery_journal(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

784

if (journal == NULL)

drivers/md/dm-vdo/recovery-journal.c

787

vdo_free(vdo_forget(journal->lock_counter.logical_zone_counts));

drivers/md/dm-vdo/recovery-journal.c

788

vdo_free(vdo_forget(journal->lock_counter.physical_zone_counts));

drivers/md/dm-vdo/recovery-journal.c

789

vdo_free(vdo_forget(journal->lock_counter.journal_counters));

drivers/md/dm-vdo/recovery-journal.c

790

vdo_free(vdo_forget(journal->lock_counter.journal_decrement_counts));

drivers/md/dm-vdo/recovery-journal.c

791

vdo_free(vdo_forget(journal->lock_counter.logical_counters));

drivers/md/dm-vdo/recovery-journal.c

792

vdo_free(vdo_forget(journal->lock_counter.physical_counters));

drivers/md/dm-vdo/recovery-journal.c

793

free_vio(vdo_forget(journal->flush_vio));

drivers/md/dm-vdo/recovery-journal.c

799

if (!vdo_is_state_quiescent(&journal->state)) {

drivers/md/dm-vdo/recovery-journal.c

800

VDO_ASSERT_LOG_ONLY(list_empty(&journal->active_tail_blocks),

drivers/md/dm-vdo/recovery-journal.c

802

} else if (!vdo_is_state_saved(&journal->state) &&

drivers/md/dm-vdo/recovery-journal.c

803

!list_empty(&journal->active_tail_blocks)) {

drivers/md/dm-vdo/recovery-journal.c

808

struct recovery_journal_block *block = &journal->blocks[i];

drivers/md/dm-vdo/recovery-journal.c

814

vdo_free(journal);

drivers/md/dm-vdo/recovery-journal.c

825

void vdo_initialize_recovery_journal_post_repair(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

831

set_journal_tail(journal, tail + 1);

drivers/md/dm-vdo/recovery-journal.c

832

journal->recovery_count = compute_recovery_count_byte(recovery_count);

drivers/md/dm-vdo/recovery-journal.c

833

initialize_journal_state(journal);

drivers/md/dm-vdo/recovery-journal.c

834

journal->logical_blocks_used = logical_blocks_used;

drivers/md/dm-vdo/recovery-journal.c

835

journal->block_map_data_blocks = block_map_data_blocks;

drivers/md/dm-vdo/recovery-journal.c

845

block_count_t vdo_get_journal_block_map_data_blocks_used(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

847

return journal->block_map_data_blocks;

drivers/md/dm-vdo/recovery-journal.c

85

static inline u16 *get_counter(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

856

thread_id_t vdo_get_recovery_journal_thread_id(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

858

return journal->thread_id;

drivers/md/dm-vdo/recovery-journal.c

867

void vdo_open_recovery_journal(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.c

870

journal->depot = depot;

drivers/md/dm-vdo/recovery-journal.c

871

journal->block_map = block_map;

drivers/md/dm-vdo/recovery-journal.c

872

WRITE_ONCE(journal->state.current_state, VDO_ADMIN_STATE_NORMAL_OPERATION);

drivers/md/dm-vdo/recovery-journal.c

883

vdo_record_recovery_journal(const struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

886

.logical_blocks_used = journal->logical_blocks_used,

drivers/md/dm-vdo/recovery-journal.c

887

.block_map_data_blocks = journal->block_map_data_blocks,

drivers/md/dm-vdo/recovery-journal.c

89

struct lock_counter *counter = &journal->lock_counter;

drivers/md/dm-vdo/recovery-journal.c

890

if (vdo_is_state_saved(&journal->state)) {

drivers/md/dm-vdo/recovery-journal.c

895

state.journal_start = journal->tail;

drivers/md/dm-vdo/recovery-journal.c

901

state.journal_start = get_recovery_journal_head(journal);

drivers/md/dm-vdo/recovery-journal.c

928

block->sector->recovery_count = block->journal->recovery_count;

drivers/md/dm-vdo/recovery-journal.c

938

static bool advance_tail(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

944

block = journal->active_block = pop_free_list(journal);

drivers/md/dm-vdo/recovery-journal.c

948

list_move_tail(&block->list_node, &journal->active_tail_blocks);

drivers/md/dm-vdo/recovery-journal.c

952

.block_map_data_blocks = journal->block_map_data_blocks,

drivers/md/dm-vdo/recovery-journal.c

953

.logical_blocks_used = journal->logical_blocks_used,

drivers/md/dm-vdo/recovery-journal.c

954

.nonce = journal->nonce,

drivers/md/dm-vdo/recovery-journal.c

955

.recovery_count = journal->recovery_count,

drivers/md/dm-vdo/recovery-journal.c

956

.sequence_number = journal->tail,

drivers/md/dm-vdo/recovery-journal.c

957

.check_byte = vdo_compute_recovery_journal_check_byte(journal,

drivers/md/dm-vdo/recovery-journal.c

958

journal->tail),

drivers/md/dm-vdo/recovery-journal.c

963

block->sequence_number = journal->tail;

drivers/md/dm-vdo/recovery-journal.c

966

block->block_number = vdo_get_recovery_journal_block_number(journal,

drivers/md/dm-vdo/recovery-journal.c

967

journal->tail);

drivers/md/dm-vdo/recovery-journal.c

971

set_journal_tail(journal, journal->tail + 1);

drivers/md/dm-vdo/recovery-journal.c

972

vdo_advance_block_map_era(journal->block_map, journal->tail);

drivers/md/dm-vdo/recovery-journal.c

982

static void initialize_lock_count(struct recovery_journal *journal)

drivers/md/dm-vdo/recovery-journal.c

985

block_count_t lock_number = journal->active_block->block_number;

drivers/md/dm-vdo/recovery-journal.c

986

atomic_t *decrement_counter = get_decrement_counter(journal, lock_number);

drivers/md/dm-vdo/recovery-journal.c

988

journal_value = get_counter(journal, lock_number, VDO_ZONE_TYPE_JOURNAL, 0);

drivers/md/dm-vdo/recovery-journal.c

991

*journal_value = journal->entries_per_block + 1;

drivers/md/dm-vdo/recovery-journal.h

122

struct recovery_journal *journal;

drivers/md/dm-vdo/recovery-journal.h

229

vdo_get_recovery_journal_block_number(const struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.h

236

return vdo_compute_recovery_journal_block_number(journal->size, sequence);

drivers/md/dm-vdo/recovery-journal.h

247

vdo_compute_recovery_journal_check_byte(const struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.h

251

return (((sequence / journal->size) & 0x7F) | 0x80);

drivers/md/dm-vdo/recovery-journal.h

261

void vdo_free_recovery_journal(struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.h

263

void vdo_initialize_recovery_journal_post_repair(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.h

270

vdo_get_journal_block_map_data_blocks_used(struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.h

272

thread_id_t __must_check vdo_get_recovery_journal_thread_id(struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.h

274

void vdo_open_recovery_journal(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.h

278

vdo_get_recovery_journal_current_sequence_number(struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.h

283

vdo_record_recovery_journal(const struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.h

285

void vdo_add_recovery_journal_entry(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.h

288

void vdo_acquire_recovery_journal_block_reference(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.h

293

void vdo_release_recovery_journal_block_reference(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.h

298

void vdo_release_journal_entry_lock(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.h

301

void vdo_drain_recovery_journal(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.h

305

void vdo_resume_recovery_journal(struct recovery_journal *journal,

drivers/md/dm-vdo/recovery-journal.h

309

vdo_get_recovery_journal_logical_blocks_used(const struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.h

312

vdo_get_recovery_journal_statistics(const struct recovery_journal *journal);

drivers/md/dm-vdo/recovery-journal.h

314

void vdo_dump_recovery_journal_statistics(const struct recovery_journal *journal);

drivers/md/dm-vdo/repair.c

1161

get_recovery_journal_block_header(struct recovery_journal *journal, char *data,

drivers/md/dm-vdo/repair.c

1165

vdo_get_recovery_journal_block_number(journal, sequence);

drivers/md/dm-vdo/repair.c

1183

static bool __must_check is_valid_recovery_journal_block(const struct recovery_journal *journal,

drivers/md/dm-vdo/repair.c

1187

if ((header->nonce != journal->nonce) ||

drivers/md/dm-vdo/repair.c

1188

(header->recovery_count != journal->recovery_count))

drivers/md/dm-vdo/repair.c

1192

return (header->entry_count <= journal->entries_per_block);

drivers/md/dm-vdo/repair.c

1208

static bool __must_check is_exact_recovery_journal_block(const struct recovery_journal *journal,

drivers/md/dm-vdo/repair.c

1213

(is_valid_recovery_journal_block(journal, header, true)));

drivers/md/dm-vdo/repair.c

1224

struct recovery_journal *journal = repair->completion.vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

1233

repair->highest_tail = journal->tail;

drivers/md/dm-vdo/repair.c

1234

for (i = 0; i < journal->size; i++) {

drivers/md/dm-vdo/repair.c

1236

get_recovery_journal_block_header(journal, repair->journal_data, i);

drivers/md/dm-vdo/repair.c

1238

if (!is_valid_recovery_journal_block(journal, &header, true)) {

drivers/md/dm-vdo/repair.c

1243

if (vdo_get_recovery_journal_block_number(journal, header.sequence_number) != i) {

drivers/md/dm-vdo/repair.c

1361

struct recovery_journal *journal,

drivers/md/dm-vdo/repair.c

1368

get_recovery_journal_block_header(journal, repair->journal_data,

drivers/md/dm-vdo/repair.c

1371

if (!is_exact_recovery_journal_block(journal, &header, sequence) ||

drivers/md/dm-vdo/repair.c

1380

get_sector(journal, repair->journal_data, sequence, i);

drivers/md/dm-vdo/repair.c

1407

struct recovery_journal *journal = vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

1408

journal_entry_count_t entries_per_block = journal->entries_per_block;

drivers/md/dm-vdo/repair.c

1410

format = get_recovery_journal_block_header(journal, repair->journal_data,

drivers/md/dm-vdo/repair.c

1425

extract_entries_from_block(repair, journal, i, format, entries_per_block);

drivers/md/dm-vdo/repair.c

1516

struct recovery_journal *journal = vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

1518

get_recovery_journal_block_header(journal, repair->journal_data,

drivers/md/dm-vdo/repair.c

1555

struct recovery_journal *journal = repair->completion.vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

1560

header = get_recovery_journal_block_header(journal, repair->journal_data, head);

drivers/md/dm-vdo/repair.c

1573

header = get_recovery_journal_block_header(journal, repair->journal_data, i);

drivers/md/dm-vdo/repair.c

1574

if (!is_exact_recovery_journal_block(journal, &header, i)) {

drivers/md/dm-vdo/repair.c

1590

get_sector(journal, repair->journal_data, i, j);

drivers/md/dm-vdo/repair.c

1614

if ((header.entry_count != journal->entries_per_block) || (block_entries > 0))

drivers/md/dm-vdo/repair.c

1697

struct recovery_journal *journal = vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

1698

physical_block_number_t pbn = journal->origin;

drivers/md/dm-vdo/repair.c

1699

block_count_t remaining = journal->size;

drivers/md/dm-vdo/repair.c

714

static struct packed_journal_sector * __must_check get_sector(struct recovery_journal *journal,

drivers/md/dm-vdo/repair.c

721

offset = ((vdo_get_recovery_journal_block_number(journal, sequence) * VDO_BLOCK_SIZE) +

drivers/md/dm-vdo/repair.c

798

struct recovery_journal *journal = vdo->recovery_journal;

drivers/md/dm-vdo/repair.c

807

advance_points(repair, journal->entries_per_block)) {

drivers/md/dm-vdo/slab-depot.c

100

static void initialize_journal_state(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

1009

static bool requires_reaping(const struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

1011

return (journal_length(journal) >= journal->blocking_threshold);

drivers/md/dm-vdo/slab-depot.c

102

journal->unreapable = journal->head;

drivers/md/dm-vdo/slab-depot.c

103

journal->reap_lock = get_lock(journal, journal->unreapable);

drivers/md/dm-vdo/slab-depot.c

104

journal->next_commit = journal->tail;

drivers/md/dm-vdo/slab-depot.c

105

journal->summarized = journal->last_summarized = journal->tail;

drivers/md/dm-vdo/slab-depot.c

106

initialize_tail_block(journal);

drivers/md/dm-vdo/slab-depot.c

1077

adjust_slab_journal_block_reference(&slab->journal,

drivers/md/dm-vdo/slab-depot.c

115

static bool __must_check block_is_full(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

117

journal_entry_count_t count = journal->tail_header.entry_count;

drivers/md/dm-vdo/slab-depot.c

119

return (journal->tail_header.has_block_map_increments ?

drivers/md/dm-vdo/slab-depot.c

120

(journal->full_entries_per_block == count) :

drivers/md/dm-vdo/slab-depot.c

121

(journal->entries_per_block == count));

drivers/md/dm-vdo/slab-depot.c

1220

static void reclaim_journal_space(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

1222

block_count_t length = journal_length(journal);

drivers/md/dm-vdo/slab-depot.c

1223

struct vdo_slab *slab = journal->slab;

drivers/md/dm-vdo/slab-depot.c

1227

if ((length < journal->flushing_threshold) || (write_count == 0))

drivers/md/dm-vdo/slab-depot.c

1231

WRITE_ONCE(journal->events->flush_count, journal->events->flush_count + 1);

drivers/md/dm-vdo/slab-depot.c

1232

if (length < journal->flushing_deadline) {

drivers/md/dm-vdo/slab-depot.c

1234

write_count /= journal->flushing_deadline - length + 1;

drivers/md/dm-vdo/slab-depot.c

124

static void add_entries(struct slab_journal *journal);

drivers/md/dm-vdo/slab-depot.c

125

static void update_tail_block_location(struct slab_journal *journal);

drivers/md/dm-vdo/slab-depot.c

138

return ((slab->journal.tail == 1) &&

drivers/md/dm-vdo/slab-depot.c

139

(slab->journal.tail_header.entry_count == 0));

drivers/md/dm-vdo/slab-depot.c

148

static void mark_slab_journal_dirty(struct slab_journal *journal, sequence_number_t lock)

drivers/md/dm-vdo/slab-depot.c

151

struct list_head *dirty_list = &journal->slab->allocator->dirty_slab_journals;

drivers/md/dm-vdo/slab-depot.c

153

VDO_ASSERT_LOG_ONLY(journal->recovery_lock == 0, "slab journal was clean");

drivers/md/dm-vdo/slab-depot.c

155

journal->recovery_lock = lock;

drivers/md/dm-vdo/slab-depot.c

157

if (dirty_journal->recovery_lock <= journal->recovery_lock)

drivers/md/dm-vdo/slab-depot.c

161

list_move_tail(&journal->dirty_entry, dirty_journal->dirty_entry.next);

drivers/md/dm-vdo/slab-depot.c

164

static void mark_slab_journal_clean(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

166

journal->recovery_lock = 0;

drivers/md/dm-vdo/slab-depot.c

1665

adjust_slab_journal_block_reference(&slab->journal, entry_lock, -1);

drivers/md/dm-vdo/slab-depot.c

167

list_del_init(&journal->dirty_entry);

drivers/md/dm-vdo/slab-depot.c

1697

struct slab_journal *journal = context;

drivers/md/dm-vdo/slab-depot.c

1698

struct slab_journal_block_header *header = &journal->tail_header;

drivers/md/dm-vdo/slab-depot.c

1710

get_lock(journal, header->sequence_number)->recovery_start = recovery_block;

drivers/md/dm-vdo/slab-depot.c

1711

if (journal->recovery_journal != NULL) {

drivers/md/dm-vdo/slab-depot.c

1712

zone_count_t zone_number = journal->slab->allocator->zone_number;

drivers/md/dm-vdo/slab-depot.c

1714

vdo_acquire_recovery_journal_block_reference(journal->recovery_journal,

drivers/md/dm-vdo/slab-depot.c

1720

mark_slab_journal_dirty(journal, recovery_block);

drivers/md/dm-vdo/slab-depot.c

1721

reclaim_journal_space(journal);

drivers/md/dm-vdo/slab-depot.c

1724

add_entry(journal, updater->zpbn.pbn, updater->operation, updater->increment,

drivers/md/dm-vdo/slab-depot.c

1728

if (journal->slab->status != VDO_SLAB_REBUILT) {

drivers/md/dm-vdo/slab-depot.c

173

struct slab_journal *journal = &slab->journal;

drivers/md/dm-vdo/slab-depot.c

1733

adjust_slab_journal_block_reference(journal,

drivers/md/dm-vdo/slab-depot.c

1738

result = adjust_reference_count(journal->slab, updater,

drivers/md/dm-vdo/slab-depot.c

1755

static inline bool is_next_entry_a_block_map_increment(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

1757

struct vdo_waiter *waiter = vdo_waitq_get_first_waiter(&journal->entry_waiters);

drivers/md/dm-vdo/slab-depot.c

177

must_make_entries_to_flush(journal) ||

drivers/md/dm-vdo/slab-depot.c

1771

static void add_entries(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

1773

if (journal->adding_entries) {

drivers/md/dm-vdo/slab-depot.c

1778

journal->adding_entries = true;

drivers/md/dm-vdo/slab-depot.c

1779

while (vdo_waitq_has_waiters(&journal->entry_waiters)) {

drivers/md/dm-vdo/slab-depot.c

178

is_reaping(journal) ||

drivers/md/dm-vdo/slab-depot.c

1780

struct slab_journal_block_header *header = &journal->tail_header;

drivers/md/dm-vdo/slab-depot.c

1782

if (journal->partial_write_in_progress ||

drivers/md/dm-vdo/slab-depot.c

1783

(journal->slab->status == VDO_SLAB_REBUILDING)) {

drivers/md/dm-vdo/slab-depot.c

179

journal->waiting_to_commit ||

drivers/md/dm-vdo/slab-depot.c

1791

if (journal->waiting_to_commit) {

drivers/md/dm-vdo/slab-depot.c

1796

WRITE_ONCE(journal->events->tail_busy_count,

drivers/md/dm-vdo/slab-depot.c

1797

journal->events->tail_busy_count + 1);

drivers/md/dm-vdo/slab-depot.c

1799

} else if (is_next_entry_a_block_map_increment(journal) &&

drivers/md/dm-vdo/slab-depot.c

180

!list_empty(&journal->uncommitted_blocks) ||

drivers/md/dm-vdo/slab-depot.c

1800

(header->entry_count >= journal->full_entries_per_block)) {

drivers/md/dm-vdo/slab-depot.c

1805

commit_tail(journal);

drivers/md/dm-vdo/slab-depot.c

1806

if (journal->waiting_to_commit) {

drivers/md/dm-vdo/slab-depot.c

1807

WRITE_ONCE(journal->events->tail_busy_count,

drivers/md/dm-vdo/slab-depot.c

1808

journal->events->tail_busy_count + 1);

drivers/md/dm-vdo/slab-depot.c

181

journal->updating_slab_summary ||

drivers/md/dm-vdo/slab-depot.c

1814

if (requires_reaping(journal)) {

drivers/md/dm-vdo/slab-depot.c

1815

WRITE_ONCE(journal->events->blocked_count,

drivers/md/dm-vdo/slab-depot.c

1816

journal->events->blocked_count + 1);

drivers/md/dm-vdo/slab-depot.c

1817

save_dirty_reference_blocks(journal->slab);

drivers/md/dm-vdo/slab-depot.c

1823

get_lock(journal, header->sequence_number);

drivers/md/dm-vdo/slab-depot.c

1830

VDO_ASSERT_LOG_ONLY((journal->head + journal->size) == journal->tail,

drivers/md/dm-vdo/slab-depot.c

1838

VDO_ASSERT_LOG_ONLY((journal->blocking_threshold >= journal->size),

drivers/md/dm-vdo/slab-depot.c

1841

WRITE_ONCE(journal->events->disk_full_count,

drivers/md/dm-vdo/slab-depot.c

1842

journal->events->disk_full_count + 1);

drivers/md/dm-vdo/slab-depot.c

1843

save_dirty_reference_blocks(journal->slab);

drivers/md/dm-vdo/slab-depot.c

1852

lock->count = journal->entries_per_block + 1;

drivers/md/dm-vdo/slab-depot.c

1855

struct vdo_slab *slab = journal->slab;

drivers/md/dm-vdo/slab-depot.c

1871

adjust_slab_journal_block_reference(journal, 1,

drivers/md/dm-vdo/slab-depot.c

1876

vdo_waitq_notify_next_waiter(&journal->entry_waiters,

drivers/md/dm-vdo/slab-depot.c

1877

add_entry_from_waiter, journal);

drivers/md/dm-vdo/slab-depot.c

1880

journal->adding_entries = false;

drivers/md/dm-vdo/slab-depot.c

1883

if (vdo_is_state_draining(&journal->slab->state) &&

drivers/md/dm-vdo/slab-depot.c

1884

!vdo_is_state_suspending(&journal->slab->state) &&

drivers/md/dm-vdo/slab-depot.c

1885

!vdo_waitq_has_waiters(&journal->entry_waiters))

drivers/md/dm-vdo/slab-depot.c

1886

commit_tail(journal);

drivers/md/dm-vdo/slab-depot.c

2404

commit_tail(&slab->journal);

drivers/md/dm-vdo/slab-depot.c

2495

struct slab_journal *journal = completion->parent;

drivers/md/dm-vdo/slab-depot.c

2496

struct vdo_slab *slab = journal->slab;

drivers/md/dm-vdo/slab-depot.c

2505

journal->tail = header.sequence_number + 1;

drivers/md/dm-vdo/slab-depot.c

2511

journal->head = (slab->allocator->summary_entries[slab->slab_number].is_dirty ?

drivers/md/dm-vdo/slab-depot.c

2512

header.head : journal->tail);

drivers/md/dm-vdo/slab-depot.c

2513

journal->tail_header = header;

drivers/md/dm-vdo/slab-depot.c

2514

initialize_journal_state(journal);

drivers/md/dm-vdo/slab-depot.c

2524

struct slab_journal *journal = vio->completion.parent;

drivers/md/dm-vdo/slab-depot.c

2527

journal->slab->allocator->thread_id);

drivers/md/dm-vdo/slab-depot.c

2533

struct slab_journal *journal = completion->parent;

drivers/md/dm-vdo/slab-depot.c

2538

vdo_finish_loading_with_result(&journal->slab->state, result);

drivers/md/dm-vdo/slab-depot.c

2551

struct slab_journal *journal =

drivers/md/dm-vdo/slab-depot.c

2553

struct vdo_slab *slab = journal->slab;

drivers/md/dm-vdo/slab-depot.c

2564

(tail_block_offset_t)(journal->size - 1) :

drivers/md/dm-vdo/slab-depot.c

2567

vio->completion.parent = journal;

drivers/md/dm-vdo/slab-depot.c

2580

struct slab_journal *journal = &slab->journal;

drivers/md/dm-vdo/slab-depot.c

2591

VDO_ASSERT_LOG_ONLY(((journal->size < 16) ||

drivers/md/dm-vdo/slab-depot.c

2592

(journal->scrubbing_threshold < (journal->size - 1))),

drivers/md/dm-vdo/slab-depot.c

2599

journal->resource_waiter.callback = read_slab_journal_tail;

drivers/md/dm-vdo/slab-depot.c

2600

acquire_vio_from_pool(slab->allocator->vio_pool, &journal->resource_waiter);

drivers/md/dm-vdo/slab-depot.c

2911

struct slab_journal *journal = &slab->journal;

drivers/md/dm-vdo/slab-depot.c

2914

sequence_number_t tail = journal->tail;

drivers/md/dm-vdo/slab-depot.c

2915

tail_block_offset_t end_index = (tail - 1) % journal->size;

drivers/md/dm-vdo/slab-depot.c

2921

tail_block_offset_t head_index = head % journal->size;

drivers/md/dm-vdo/slab-depot.c

2939

(header.entry_count > journal->entries_per_block) ||

drivers/md/dm-vdo/slab-depot.c

2941

(header.entry_count > journal->full_entries_per_block))) {

drivers/md/dm-vdo/slab-depot.c

2958

if (index == journal->size)

drivers/md/dm-vdo/slab-depot.c

3174

vdo_waitq_notify_all_waiters(&slab->journal.entry_waiters,

drivers/md/dm-vdo/slab-depot.c

3175

abort_waiter, &slab->journal);

drivers/md/dm-vdo/slab-depot.c

3338

vdo_waitq_enqueue_waiter(&slab->journal.entry_waiters, &updater->waiter);

drivers/md/dm-vdo/slab-depot.c

3339

if ((slab->status != VDO_SLAB_REBUILT) && requires_reaping(&slab->journal))

drivers/md/dm-vdo/slab-depot.c

3342

add_entries(&slab->journal);

drivers/md/dm-vdo/slab-depot.c

3609

struct slab_journal *journal;

drivers/md/dm-vdo/slab-depot.c

3623

journal = &slab->journal;

drivers/md/dm-vdo/slab-depot.c

3626

(journal_length(journal) >= journal->scrubbing_threshold));

drivers/md/dm-vdo/slab-depot.c

3661

struct slab_journal *journal = &slab->journal;

drivers/md/dm-vdo/slab-depot.c

3674

vdo_waitq_num_waiters(&journal->entry_waiters),

drivers/md/dm-vdo/slab-depot.c

3675

vdo_bool_to_string(journal->waiting_to_commit),

drivers/md/dm-vdo/slab-depot.c

3676

vdo_bool_to_string(journal->updating_slab_summary),

drivers/md/dm-vdo/slab-depot.c

3677

(unsigned long long) journal->head,

drivers/md/dm-vdo/slab-depot.c

3678

(unsigned long long) journal->unreapable,

drivers/md/dm-vdo/slab-depot.c

3679

(unsigned long long) journal->tail,

drivers/md/dm-vdo/slab-depot.c

3680

(unsigned long long) journal->next_commit,

drivers/md/dm-vdo/slab-depot.c

3681

(unsigned long long) journal->summarized,

drivers/md/dm-vdo/slab-depot.c

3682

(unsigned long long) journal->last_summarized,

drivers/md/dm-vdo/slab-depot.c

3683

(unsigned long long) journal->recovery_lock,

drivers/md/dm-vdo/slab-depot.c

3684

vdo_bool_to_string(journal->recovery_lock != 0));

drivers/md/dm-vdo/slab-depot.c

3726

vdo_free(vdo_forget(slab->journal.block));

drivers/md/dm-vdo/slab-depot.c

3727

vdo_free(vdo_forget(slab->journal.locks));

drivers/md/dm-vdo/slab-depot.c

3735

struct slab_journal *journal = &slab->journal;

drivers/md/dm-vdo/slab-depot.c

3739

result = vdo_allocate(slab_config->slab_journal_blocks, __func__, &journal->locks);

drivers/md/dm-vdo/slab-depot.c

3743

BUILD_BUG_ON(sizeof(*journal->block) != VDO_BLOCK_SIZE);

drivers/md/dm-vdo/slab-depot.c

3744

result = vdo_allocate(1, "struct packed_slab_journal_block", &journal->block);

drivers/md/dm-vdo/slab-depot.c

3748

journal->slab = slab;

drivers/md/dm-vdo/slab-depot.c

3749

journal->size = slab_config->slab_journal_blocks;

drivers/md/dm-vdo/slab-depot.c

3750

journal->flushing_threshold = slab_config->slab_journal_flushing_threshold;

drivers/md/dm-vdo/slab-depot.c

3751

journal->blocking_threshold = slab_config->slab_journal_blocking_threshold;

drivers/md/dm-vdo/slab-depot.c

3752

journal->scrubbing_threshold = slab_config->slab_journal_scrubbing_threshold;

drivers/md/dm-vdo/slab-depot.c

3753

journal->entries_per_block = VDO_SLAB_JOURNAL_ENTRIES_PER_BLOCK;

drivers/md/dm-vdo/slab-depot.c

3754

journal->full_entries_per_block = VDO_SLAB_JOURNAL_FULL_ENTRIES_PER_BLOCK;

drivers/md/dm-vdo/slab-depot.c

3755

journal->events = &slab->allocator->slab_journal_statistics;

drivers/md/dm-vdo/slab-depot.c

3756

journal->recovery_journal = slab->allocator->depot->vdo->recovery_journal;

drivers/md/dm-vdo/slab-depot.c

3757

journal->tail = 1;

drivers/md/dm-vdo/slab-depot.c

3758

journal->head = 1;

drivers/md/dm-vdo/slab-depot.c

3760

journal->flushing_deadline = journal->flushing_threshold;

drivers/md/dm-vdo/slab-depot.c

3765

if ((journal->blocking_threshold - journal->flushing_threshold) > 5)

drivers/md/dm-vdo/slab-depot.c

3766

journal->flushing_deadline = journal->blocking_threshold - 5;

drivers/md/dm-vdo/slab-depot.c

3768

journal->slab_summary_waiter.callback = release_journal_locks;

drivers/md/dm-vdo/slab-depot.c

3770

INIT_LIST_HEAD(&journal->dirty_entry);

drivers/md/dm-vdo/slab-depot.c

3771

INIT_LIST_HEAD(&journal->uncommitted_blocks);

drivers/md/dm-vdo/slab-depot.c

3773

journal->tail_header.nonce = slab->allocator->nonce;

drivers/md/dm-vdo/slab-depot.c

3774

journal->tail_header.metadata_type = VDO_METADATA_SLAB_JOURNAL;

drivers/md/dm-vdo/slab-depot.c

3775

initialize_journal_state(journal);

drivers/md/dm-vdo/slab-depot.c

3918

static bool __must_check release_recovery_journal_lock(struct slab_journal *journal,

drivers/md/dm-vdo/slab-depot.c

3921

if (recovery_lock > journal->recovery_lock) {

drivers/md/dm-vdo/slab-depot.c

3922

VDO_ASSERT_LOG_ONLY((recovery_lock < journal->recovery_lock),

drivers/md/dm-vdo/slab-depot.c

3927

if ((recovery_lock < journal->recovery_lock) ||

drivers/md/dm-vdo/slab-depot.c

3928

vdo_is_read_only(journal->slab->allocator->depot->vdo))

drivers/md/dm-vdo/slab-depot.c

3932

commit_tail(journal);

drivers/md/dm-vdo/slab-depot.c

3945

struct slab_journal *journal, *tmp;

drivers/md/dm-vdo/slab-depot.c

3949

list_for_each_entry_safe(journal, tmp, list, dirty_entry) {

drivers/md/dm-vdo/slab-depot.c

3950

if (!release_recovery_journal_lock(journal,

drivers/md/dm-vdo/slab-depot.c

401

static void finish_reaping(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

403

journal->head = journal->unreapable;

drivers/md/dm-vdo/slab-depot.c

404

add_entries(journal);

drivers/md/dm-vdo/slab-depot.c

405

check_if_slab_drained(journal->slab);

drivers/md/dm-vdo/slab-depot.c

408

static void reap_slab_journal(struct slab_journal *journal);

drivers/md/dm-vdo/slab-depot.c

417

struct slab_journal *journal = completion->parent;

drivers/md/dm-vdo/slab-depot.c

420

finish_reaping(journal);

drivers/md/dm-vdo/slab-depot.c

421

reap_slab_journal(journal);

drivers/md/dm-vdo/slab-depot.c

438

struct slab_journal *journal = vio->completion.parent;

drivers/md/dm-vdo/slab-depot.c

441

journal->slab->allocator->thread_id);

drivers/md/dm-vdo/slab-depot.c

452

struct slab_journal *journal =

drivers/md/dm-vdo/slab-depot.c

457

vio->completion.parent = journal;

drivers/md/dm-vdo/slab-depot.c

465

static void reap_slab_journal(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

469

if (is_reaping(journal)) {

drivers/md/dm-vdo/slab-depot.c

474

if ((journal->slab->status != VDO_SLAB_REBUILT) ||

drivers/md/dm-vdo/slab-depot.c

475

!vdo_is_state_normal(&journal->slab->state) ||

drivers/md/dm-vdo/slab-depot.c

476

vdo_is_read_only(journal->slab->allocator->depot->vdo)) {

drivers/md/dm-vdo/slab-depot.c

48

static inline struct journal_lock * __must_check get_lock(struct slab_journal *journal,

drivers/md/dm-vdo/slab-depot.c

488

while ((journal->unreapable < journal->tail) && (journal->reap_lock->count == 0)) {

drivers/md/dm-vdo/slab-depot.c

490

journal->unreapable++;

drivers/md/dm-vdo/slab-depot.c

491

journal->reap_lock++;

drivers/md/dm-vdo/slab-depot.c

492

if (journal->reap_lock == &journal->locks[journal->size])

drivers/md/dm-vdo/slab-depot.c

493

journal->reap_lock = &journal->locks[0];

drivers/md/dm-vdo/slab-depot.c

509

journal->flush_waiter.callback = flush_for_reaping;

drivers/md/dm-vdo/slab-depot.c

51

return &journal->locks[sequence_number % journal->size];

drivers/md/dm-vdo/slab-depot.c

510

acquire_vio_from_pool(journal->slab->allocator->vio_pool,

drivers/md/dm-vdo/slab-depot.c

511

&journal->flush_waiter);

drivers/md/dm-vdo/slab-depot.c

522

static void adjust_slab_journal_block_reference(struct slab_journal *journal,

drivers/md/dm-vdo/slab-depot.c

531

if (journal->slab->status == VDO_SLAB_REPLAYING) {

drivers/md/dm-vdo/slab-depot.c

537

lock = get_lock(journal, sequence_number);

drivers/md/dm-vdo/slab-depot.c

547

reap_slab_journal(journal);

drivers/md/dm-vdo/slab-depot.c

562

struct slab_journal *journal =

drivers/md/dm-vdo/slab-depot.c

573

(unsigned long long) journal->summarized);

drivers/md/dm-vdo/slab-depot.c

576

journal->updating_slab_summary = false;

drivers/md/dm-vdo/slab-depot.c

577

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

578

check_if_slab_drained(journal->slab);

drivers/md/dm-vdo/slab-depot.c

582

if (journal->partial_write_in_progress && (journal->summarized == journal->tail)) {

drivers/md/dm-vdo/slab-depot.c

583

journal->partial_write_in_progress = false;

drivers/md/dm-vdo/slab-depot.c

584

add_entries(journal);

drivers/md/dm-vdo/slab-depot.c

587

first = journal->last_summarized;

drivers/md/dm-vdo/slab-depot.c

588

journal->last_summarized = journal->summarized;

drivers/md/dm-vdo/slab-depot.c

589

for (i = journal->summarized - 1; i >= first; i--) {

drivers/md/dm-vdo/slab-depot.c

594

if (journal->recovery_journal != NULL) {

drivers/md/dm-vdo/slab-depot.c

595

zone_count_t zone_number = journal->slab->allocator->zone_number;

drivers/md/dm-vdo/slab-depot.c

596

struct journal_lock *lock = get_lock(journal, i);

drivers/md/dm-vdo/slab-depot.c

598

vdo_release_recovery_journal_block_reference(journal->recovery_journal,

drivers/md/dm-vdo/slab-depot.c

608

adjust_slab_journal_block_reference(journal, i, -1);

drivers/md/dm-vdo/slab-depot.c

611

journal->updating_slab_summary = false;

drivers/md/dm-vdo/slab-depot.c

613

reap_slab_journal(journal);

drivers/md/dm-vdo/slab-depot.c

616

update_tail_block_location(journal);

drivers/md/dm-vdo/slab-depot.c

623

static void update_tail_block_location(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

626

struct vdo_slab *slab = journal->slab;

drivers/md/dm-vdo/slab-depot.c

628

if (journal->updating_slab_summary ||

drivers/md/dm-vdo/slab-depot.c

629

vdo_is_read_only(journal->slab->allocator->depot->vdo) ||

drivers/md/dm-vdo/slab-depot.c

630

(journal->last_summarized >= journal->next_commit)) {

drivers/md/dm-vdo/slab-depot.c

643

journal->summarized = journal->next_commit;

drivers/md/dm-vdo/slab-depot.c

644

journal->updating_slab_summary = true;

drivers/md/dm-vdo/slab-depot.c

652

update_slab_summary_entry(slab, &journal->slab_summary_waiter,

drivers/md/dm-vdo/slab-depot.c

653

journal->summarized % journal->size,

drivers/md/dm-vdo/slab-depot.c

654

(journal->head > 1), false, free_block_count);

drivers/md/dm-vdo/slab-depot.c

66

static inline bool __must_check must_make_entries_to_flush(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

663

struct slab_journal *journal = &slab->journal;

drivers/md/dm-vdo/slab-depot.c

666

VDO_ASSERT_LOG_ONLY(journal->tail_header.entry_count == 0,

drivers/md/dm-vdo/slab-depot.c

668

journal->head = journal->tail;

drivers/md/dm-vdo/slab-depot.c

669

initialize_journal_state(journal);

drivers/md/dm-vdo/slab-depot.c

672

for (block = 1; block <= journal->size; block++) {

drivers/md/dm-vdo/slab-depot.c

673

VDO_ASSERT_LOG_ONLY((get_lock(journal, block)->count == 0),

drivers/md/dm-vdo/slab-depot.c

678

add_entries(journal);

drivers/md/dm-vdo/slab-depot.c

68

return ((journal->slab->status != VDO_SLAB_REBUILDING) &&

drivers/md/dm-vdo/slab-depot.c

69

vdo_waitq_has_waiters(&journal->entry_waiters));

drivers/md/dm-vdo/slab-depot.c

699

struct slab_journal *journal = completion->parent;

drivers/md/dm-vdo/slab-depot.c

709

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

710

check_if_slab_drained(journal->slab);

drivers/md/dm-vdo/slab-depot.c

714

WRITE_ONCE(journal->events->blocks_written, journal->events->blocks_written + 1);

drivers/md/dm-vdo/slab-depot.c

716

if (list_empty(&journal->uncommitted_blocks)) {

drivers/md/dm-vdo/slab-depot.c

718

journal->next_commit = journal->tail;

drivers/md/dm-vdo/slab-depot.c

721

pooled = container_of(journal->uncommitted_blocks.next,

drivers/md/dm-vdo/slab-depot.c

723

journal->next_commit = get_committing_sequence_number(pooled);

drivers/md/dm-vdo/slab-depot.c

726

update_tail_block_location(journal);

drivers/md/dm-vdo/slab-depot.c

732

struct slab_journal *journal = vio->completion.parent;

drivers/md/dm-vdo/slab-depot.c

734

continue_vio_after_io(vio, complete_write, journal->slab->allocator->thread_id);

drivers/md/dm-vdo/slab-depot.c

748

struct slab_journal *journal =

drivers/md/dm-vdo/slab-depot.c

750

struct slab_journal_block_header *header = &journal->tail_header;

drivers/md/dm-vdo/slab-depot.c

751

int unused_entries = journal->entries_per_block - header->entry_count;

drivers/md/dm-vdo/slab-depot.c

755

header->head = journal->head;

drivers/md/dm-vdo/slab-depot.c

756

list_add_tail(&pooled->list_entry, &journal->uncommitted_blocks);

drivers/md/dm-vdo/slab-depot.c

757

vdo_pack_slab_journal_block_header(header, &journal->block->header);

drivers/md/dm-vdo/slab-depot.c

760

memcpy(pooled->vio.data, journal->block, VDO_BLOCK_SIZE);

drivers/md/dm-vdo/slab-depot.c

768

adjust_slab_journal_block_reference(journal, header->sequence_number,

drivers/md/dm-vdo/slab-depot.c

770

journal->partial_write_in_progress = !block_is_full(journal);

drivers/md/dm-vdo/slab-depot.c

773

block_number = journal->slab->journal_origin +

drivers/md/dm-vdo/slab-depot.c

774

(header->sequence_number % journal->size);

drivers/md/dm-vdo/slab-depot.c

775

vio->completion.parent = journal;

drivers/md/dm-vdo/slab-depot.c

78

static inline bool __must_check is_reaping(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

786

journal->tail++;

drivers/md/dm-vdo/slab-depot.c

787

initialize_tail_block(journal);

drivers/md/dm-vdo/slab-depot.c

788

journal->waiting_to_commit = false;

drivers/md/dm-vdo/slab-depot.c

790

operation = vdo_get_admin_state_code(&journal->slab->state);

drivers/md/dm-vdo/slab-depot.c

792

vdo_finish_operation(&journal->slab->state,

drivers/md/dm-vdo/slab-depot.c

793

(vdo_is_read_only(journal->slab->allocator->depot->vdo) ?

drivers/md/dm-vdo/slab-depot.c

798

add_entries(journal);

drivers/md/dm-vdo/slab-depot.c

80

return (journal->head != journal->unreapable);

drivers/md/dm-vdo/slab-depot.c

805

static void commit_tail(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

807

if ((journal->tail_header.entry_count == 0) && must_make_entries_to_flush(journal)) {

drivers/md/dm-vdo/slab-depot.c

815

if (vdo_is_read_only(journal->slab->allocator->depot->vdo) ||

drivers/md/dm-vdo/slab-depot.c

816

journal->waiting_to_commit ||

drivers/md/dm-vdo/slab-depot.c

817

(journal->tail_header.entry_count == 0)) {

drivers/md/dm-vdo/slab-depot.c

829

mark_slab_journal_clean(journal);

drivers/md/dm-vdo/slab-depot.c

831

journal->waiting_to_commit = true;

drivers/md/dm-vdo/slab-depot.c

833

journal->resource_waiter.callback = write_slab_journal_block;

drivers/md/dm-vdo/slab-depot.c

834

acquire_vio_from_pool(journal->slab->allocator->vio_pool,

drivers/md/dm-vdo/slab-depot.c

835

&journal->resource_waiter);

drivers/md/dm-vdo/slab-depot.c

87

static void initialize_tail_block(struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

89

struct slab_journal_block_header *header = &journal->tail_header;

drivers/md/dm-vdo/slab-depot.c

903

static void add_entry(struct slab_journal *journal, physical_block_number_t pbn,

drivers/md/dm-vdo/slab-depot.c

907

struct packed_slab_journal_block *block = journal->block;

drivers/md/dm-vdo/slab-depot.c

91

header->sequence_number = journal->tail;

drivers/md/dm-vdo/slab-depot.c

910

result = VDO_ASSERT(vdo_before_journal_point(&journal->tail_header.recovery_point,

drivers/md/dm-vdo/slab-depot.c

915

(unsigned long long) journal->tail_header.recovery_point.sequence_number,

drivers/md/dm-vdo/slab-depot.c

916

journal->tail_header.recovery_point.entry_count);

drivers/md/dm-vdo/slab-depot.c

918

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo, result);

drivers/md/dm-vdo/slab-depot.c

923

result = VDO_ASSERT((journal->tail_header.entry_count <

drivers/md/dm-vdo/slab-depot.c

924

journal->full_entries_per_block),

drivers/md/dm-vdo/slab-depot.c

927

vdo_enter_read_only_mode(journal->slab->allocator->depot->vdo,

drivers/md/dm-vdo/slab-depot.c

933

encode_slab_journal_entry(&journal->tail_header, &block->payload,

drivers/md/dm-vdo/slab-depot.c

934

pbn - journal->slab->start, operation, increment);

drivers/md/dm-vdo/slab-depot.c

935

journal->tail_header.recovery_point = recovery_point;

drivers/md/dm-vdo/slab-depot.c

936

if (block_is_full(journal))

drivers/md/dm-vdo/slab-depot.c

937

commit_tail(journal);

drivers/md/dm-vdo/slab-depot.c

940

static inline block_count_t journal_length(const struct slab_journal *journal)

drivers/md/dm-vdo/slab-depot.c

942

return journal->tail - journal->head;

drivers/md/dm-vdo/slab-depot.c

962

struct slab_journal *journal = &slab->journal;

drivers/md/dm-vdo/slab-depot.c

963

struct slab_journal_block_header *header = &journal->tail_header;

drivers/md/dm-vdo/slab-depot.c

967

if (!vdo_before_journal_point(&journal->tail_header.recovery_point, &expanded))

drivers/md/dm-vdo/slab-depot.c

970

if ((header->entry_count >= journal->full_entries_per_block) &&

drivers/md/dm-vdo/slab-depot.c

976

commit_tail(journal);

drivers/md/dm-vdo/slab-depot.c

979

if (journal->waiting_to_commit) {

drivers/md/dm-vdo/slab-depot.c

980

vdo_start_operation_with_waiter(&journal->slab->state,

drivers/md/dm-vdo/slab-depot.c

986

if (journal_length(journal) >= journal->size) {

drivers/md/dm-vdo/slab-depot.c

992

journal->head++;

drivers/md/dm-vdo/slab-depot.c

993

journal->unreapable++;

drivers/md/dm-vdo/slab-depot.c

996

if (journal->slab->status == VDO_SLAB_REBUILT)

drivers/md/dm-vdo/slab-depot.c

997

journal->slab->status = VDO_SLAB_REPLAYING;

drivers/md/dm-vdo/slab-depot.c

999

add_entry(journal, pbn, operation, increment, expanded);

drivers/md/dm-vdo/slab-depot.h

222

struct slab_journal journal;

drivers/md/dm-vdo/statistics.h

230

struct recovery_journal_statistics journal;

drivers/md/dm-vdo/vdo.c

1639

struct recovery_journal *journal = vdo->recovery_journal;

drivers/md/dm-vdo/vdo.c

1667

stats->logical_blocks_used = vdo_get_recovery_journal_logical_blocks_used(journal);

drivers/md/dm-vdo/vdo.c

1669

stats->journal = vdo_get_recovery_journal_statistics(journal);

fs/ext4/block_validity.c

354

journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;

fs/ext4/block_validity.c

356

if (journal && inode == journal->j_inode)

fs/ext4/ext4.h

2271

EXT4_FEATURE_COMPAT_FUNCS(journal, HAS_JOURNAL)

fs/ext4/ext4.h

3052

void ext4_fc_init(struct super_block *sb, journal_t *journal);

fs/ext4/ext4.h

3071

int ext4_fc_commit(journal_t *journal, tid_t commit_tid);

fs/ext4/ext4_jbd2.c

111

journal = EXT4_SB(sb)->s_journal;

fs/ext4/ext4_jbd2.c

112

if (!journal || (EXT4_SB(sb)->s_mount_state & EXT4_FC_REPLAY))

fs/ext4/ext4_jbd2.c

114

return jbd2__journal_start(journal, blocks, rsv_blocks, revoke_creds,

fs/ext4/ext4_jbd2.c

67

journal_t *journal;

fs/ext4/ext4_jbd2.c

79

journal = EXT4_SB(sb)->s_journal;

fs/ext4/ext4_jbd2.c

85

if (journal && is_journal_aborted(journal)) {

fs/ext4/ext4_jbd2.c

86

ext4_abort(sb, -journal->j_errno, "Detected aborted journal");

fs/ext4/ext4_jbd2.c

97

journal_t *journal;

fs/ext4/ext4_jbd2.h

329

static inline int ext4_journal_force_commit(journal_t *journal)

fs/ext4/ext4_jbd2.h

331

if (journal)

fs/ext4/ext4_jbd2.h

332

return jbd2_journal_force_commit(journal);

fs/ext4/ext4_jbd2.h

436

static inline int ext4_journal_destroy(struct ext4_sb_info *sbi, journal_t *journal)

fs/ext4/ext4_jbd2.h

455

err = jbd2_journal_destroy(journal);

fs/ext4/fast_commit.c

1173

static int ext4_fc_flush_data(journal_t *journal)

fs/ext4/fast_commit.c

1175

struct super_block *sb = journal->j_private;

fs/ext4/fast_commit.c

1181

ret = jbd2_submit_inode_data(journal, READ_ONCE(ei->jinode));

fs/ext4/fast_commit.c

1187

ret = jbd2_wait_inode_data(journal, READ_ONCE(ei->jinode));

fs/ext4/fast_commit.c

1196

static int ext4_fc_commit_dentry_updates(journal_t *journal, u32 *crc)

fs/ext4/fast_commit.c

1198

struct super_block *sb = journal->j_private;

fs/ext4/fast_commit.c

1254

static int ext4_fc_snapshot_inodes(journal_t *journal, struct inode **inodes,

fs/ext4/fast_commit.c

1260

struct super_block *sb = journal->j_private;

fs/ext4/fast_commit.c

1339

static int ext4_fc_perform_commit(journal_t *journal, tid_t commit_tid)

fs/ext4/fast_commit.c

1341

struct super_block *sb = journal->j_private;

fs/ext4/fast_commit.c

1372

ret = ext4_fc_flush_data(journal);

fs/ext4/fast_commit.c

1412

jbd2_journal_lock_updates(journal);

fs/ext4/fast_commit.c

1427

ret = ext4_fc_snapshot_inodes(journal, inodes, inodes_size,

fs/ext4/fast_commit.c

1429

jbd2_journal_unlock_updates(journal);

fs/ext4/fast_commit.c

1447

if (journal->j_fs_dev != journal->j_dev)

fs/ext4/fast_commit.c

1448

blkdev_issue_flush(journal->j_fs_dev);

fs/ext4/fast_commit.c

1469

ret = ext4_fc_commit_dentry_updates(journal, &crc);

fs/ext4/fast_commit.c

1586

int ext4_fc_commit(journal_t *journal, tid_t commit_tid)

fs/ext4/fast_commit.c

1588

struct super_block *sb = journal->j_private;

fs/ext4/fast_commit.c

1590

int nblks = 0, ret, bsize = journal->j_blocksize;

fs/ext4/fast_commit.c

1597

return jbd2_complete_transaction(journal, commit_tid);

fs/ext4/fast_commit.c

1605

ret = jbd2_fc_begin_commit(journal, commit_tid);

fs/ext4/fast_commit.c

1609

tid_gt(commit_tid, journal->j_commit_sequence))

fs/ext4/fast_commit.c

1621

return jbd2_complete_transaction(journal, commit_tid);

fs/ext4/fast_commit.c

1637

if (journal->j_task->io_context)

fs/ext4/fast_commit.c

1643

ret = ext4_fc_perform_commit(journal, commit_tid);

fs/ext4/fast_commit.c

1652

ret = jbd2_fc_wait_bufs(journal, nblks);

fs/ext4/fast_commit.c

1658

ret = jbd2_fc_end_commit(journal);

fs/ext4/fast_commit.c

1670

ret = jbd2_fc_end_commit_fallback(journal);

fs/ext4/fast_commit.c

1679

static void ext4_fc_cleanup(journal_t *journal, int full, tid_t tid)

fs/ext4/fast_commit.c

1681

struct super_block *sb = journal->j_private;

fs/ext4/fast_commit.c

1690

trace_ext4_fc_cleanup(journal, full, tid);

fs/ext4/fast_commit.c

1691

jbd2_fc_release_bufs(journal);

fs/ext4/fast_commit.c

2458

static int ext4_fc_replay_scan(journal_t *journal,

fs/ext4/fast_commit.c

2462

struct super_block *sb = journal->j_private;

fs/ext4/fast_commit.c

2476

end = start + journal->j_blocksize;

fs/ext4/fast_commit.c

2581

static int ext4_fc_replay(journal_t *journal, struct buffer_head *bh,

fs/ext4/fast_commit.c

2584

struct super_block *sb = journal->j_private;

fs/ext4/fast_commit.c

2594

return ext4_fc_replay_scan(journal, bh, off, expected_tid);

fs/ext4/fast_commit.c

2615

end = start + journal->j_blocksize;

fs/ext4/fast_commit.c

2673

void ext4_fc_init(struct super_block *sb, journal_t *journal)

fs/ext4/fast_commit.c

2680

journal->j_fc_replay_callback = ext4_fc_replay;

fs/ext4/fast_commit.c

2683

journal->j_fc_cleanup_callback = ext4_fc_cleanup;

fs/ext4/fsmap.c

313

journal_t *journal = EXT4_SB(sb)->s_journal;

fs/ext4/fsmap.c

336

irec.fmr_physical = journal->j_blk_offset;

fs/ext4/fsmap.c

337

irec.fmr_length = journal->j_total_len;

fs/ext4/fsync.c

114

journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;

fs/ext4/fsync.c

124

if (journal->j_flags & JBD2_BARRIER &&

fs/ext4/fsync.c

125

!jbd2_trans_will_send_data_barrier(journal, commit_tid))

fs/ext4/fsync.c

128

return ext4_fc_commit(journal, commit_tid);

fs/ext4/inode.c

3415

journal_t *journal = EXT4_JOURNAL(folio->mapping->host);

fs/ext4/inode.c

3425

return jbd2_journal_invalidate_folio(journal, folio, offset, length);

fs/ext4/inode.c

3439

journal_t *journal = EXT4_JOURNAL(inode);

fs/ext4/inode.c

3446

if (journal)

fs/ext4/inode.c

3447

return jbd2_journal_try_to_free_buffers(journal, folio);

fs/ext4/inode.c

3454

journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;

fs/ext4/inode.c

3456

if (journal) {

fs/ext4/inode.c

3457

if (jbd2_transaction_committed(journal,

fs/ext4/inode.c

397

journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;

fs/ext4/inode.c

399

if (journal && inode == journal->j_inode)

fs/ext4/inode.c

5282

journal_t *journal = EXT4_SB(sb)->s_journal;

fs/ext4/inode.c

5469

if (journal) {

fs/ext4/inode.c

5473

read_lock(&journal->j_state_lock);

fs/ext4/inode.c

5474

if (journal->j_running_transaction)

fs/ext4/inode.c

5475

transaction = journal->j_running_transaction;

fs/ext4/inode.c

5477

transaction = journal->j_committing_transaction;

fs/ext4/inode.c

5481

tid = journal->j_commit_sequence;

fs/ext4/inode.c

5482

read_unlock(&journal->j_state_lock);

fs/ext4/inode.c

5870

journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;

fs/ext4/inode.c

5899

read_lock(&journal->j_state_lock);

fs/ext4/inode.c

5900

if (journal->j_committing_transaction) {

fs/ext4/inode.c

5901

commit_tid = journal->j_committing_transaction->t_tid;

fs/ext4/inode.c

5904

read_unlock(&journal->j_state_lock);

fs/ext4/inode.c

5906

jbd2_log_wait_commit(journal, commit_tid);

fs/ext4/inode.c

6645

journal_t *journal;

fs/ext4/inode.c

6660

journal = EXT4_JOURNAL(inode);

fs/ext4/inode.c

6661

if (!journal)

fs/ext4/inode.c

6663

if (is_journal_aborted(journal))

fs/ext4/inode.c

6687

jbd2_journal_lock_updates(journal);

fs/ext4/inode.c

6700

err = jbd2_journal_flush(journal, 0);

fs/ext4/inode.c

6702

jbd2_journal_unlock_updates(journal);

fs/ext4/inode.c

6712

jbd2_journal_unlock_updates(journal);

fs/ext4/super.c

476

journal_t *journal = sbi->s_journal;

fs/ext4/super.c

483

!(sb->s_flags & SB_ACTIVE) || !journal ||

fs/ext4/super.c

484

journal->j_flags & JBD2_UNMOUNT)

fs/ext4/super.c

509

static void ext4_journal_commit_callback(journal_t *journal, transaction_t *txn)

fs/ext4/super.c

511

struct super_block *sb = journal->j_private;

fs/ext4/super.c

5868

static void ext4_init_journal_params(struct super_block *sb, journal_t *journal)

fs/ext4/super.c

5872

journal->j_commit_interval = sbi->s_commit_interval;

fs/ext4/super.c

5873

journal->j_min_batch_time = sbi->s_min_batch_time;

fs/ext4/super.c

5874

journal->j_max_batch_time = sbi->s_max_batch_time;

fs/ext4/super.c

5875

ext4_fc_init(sb, journal);

fs/ext4/super.c

5877

write_lock(&journal->j_state_lock);

fs/ext4/super.c

5879

journal->j_flags |= JBD2_BARRIER;

fs/ext4/super.c

5881

journal->j_flags &= ~JBD2_BARRIER;

fs/ext4/super.c

5886

journal->j_flags |= JBD2_CYCLE_RECORD;

fs/ext4/super.c

5887

write_unlock(&journal->j_state_lock);

fs/ext4/super.c

5927

static int ext4_journal_bmap(journal_t *journal, sector_t *block)

fs/ext4/super.c

5932

if (journal->j_inode == NULL)

fs/ext4/super.c

5937

ret = ext4_map_blocks(NULL, journal->j_inode, &map, 0);

fs/ext4/super.c

5939

ext4_msg(journal->j_inode->i_sb, KERN_CRIT,

fs/ext4/super.c

5942

jbd2_journal_abort(journal, ret ? ret : -EFSCORRUPTED);

fs/ext4/super.c

5953

journal_t *journal;

fs/ext4/super.c

5959

journal = jbd2_journal_init_inode(journal_inode);

fs/ext4/super.c

5960

if (IS_ERR(journal)) {

fs/ext4/super.c

5963

return ERR_CAST(journal);

fs/ext4/super.c

5965

journal->j_private = sb;

fs/ext4/super.c

5966

journal->j_bmap = ext4_journal_bmap;

fs/ext4/super.c

5967

ext4_init_journal_params(sb, journal);

fs/ext4/super.c

5968

return journal;

fs/ext4/super.c

6053

journal_t *journal;

fs/ext4/super.c

6063

journal = jbd2_journal_init_dev(file_bdev(bdev_file), sb->s_bdev, j_start,

fs/ext4/super.c

6065

if (IS_ERR(journal)) {

fs/ext4/super.c

6067

errno = PTR_ERR(journal);

fs/ext4/super.c

6070

if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {

fs/ext4/super.c

6073

be32_to_cpu(journal->j_superblock->s_nr_users));

fs/ext4/super.c

6077

journal->j_private = sb;

fs/ext4/super.c

6079

ext4_init_journal_params(sb, journal);

fs/ext4/super.c

6080

return journal;

fs/ext4/super.c

6083

ext4_journal_destroy(EXT4_SB(sb), journal);

fs/ext4/super.c

6093

journal_t *journal;

fs/ext4/super.c

6118

journal = ext4_open_inode_journal(sb, journal_inum);

fs/ext4/super.c

6119

if (IS_ERR(journal))

fs/ext4/super.c

6120

return PTR_ERR(journal);

fs/ext4/super.c

6122

journal = ext4_open_dev_journal(sb, journal_dev);

fs/ext4/super.c

6123

if (IS_ERR(journal))

fs/ext4/super.c

6124

return PTR_ERR(journal);

fs/ext4/super.c

6127

journal_dev_ro = bdev_read_only(journal->j_dev);

fs/ext4/super.c

6158

if (!(journal->j_flags & JBD2_BARRIER))

fs/ext4/super.c

6162

err = jbd2_journal_wipe(journal, !really_read_only);

fs/ext4/super.c

6171

err = jbd2_journal_load(journal);

fs/ext4/super.c

6197

EXT4_SB(sb)->s_journal = journal;

fs/ext4/super.c

6200

ext4_journal_destroy(EXT4_SB(sb), journal);

fs/ext4/super.c

6218

ext4_journal_destroy(EXT4_SB(sb), journal);

fs/ext4/super.c

6352

journal_t *journal = EXT4_SB(sb)->s_journal;

fs/ext4/super.c

6355

if (journal != NULL) {

fs/ext4/super.c

6362

jbd2_journal_lock_updates(journal);

fs/ext4/super.c

6363

err = jbd2_journal_flush(journal, 0);

fs/ext4/super.c

6379

jbd2_journal_unlock_updates(journal);

fs/ext4/super.c

6391

journal_t *journal;

fs/ext4/super.c

6400

journal = EXT4_SB(sb)->s_journal;

fs/ext4/super.c

6407

j_errno = jbd2_journal_errno(journal);

fs/ext4/super.c

6422

jbd2_journal_clear_err(journal);

fs/ext4/super.c

6423

jbd2_journal_update_sb_errno(journal);

fs/ext4/super.c

6494

journal_t *journal = EXT4_SB(sb)->s_journal;

fs/ext4/super.c

6496

if (journal) {

fs/ext4/super.c

6498

jbd2_journal_lock_updates(journal);

fs/ext4/super.c

6504

error = jbd2_journal_flush(journal, 0);

fs/ext4/super.c

6516

if (journal)

fs/ext4/super.c

6518

jbd2_journal_unlock_updates(journal);

fs/ext4/super.c

700

journal_t *journal = EXT4_SB(sb)->s_journal;

fs/ext4/super.c

707

if (!continue_fs && !ext4_emergency_ro(sb) && journal)

fs/ext4/super.c

708

jbd2_journal_abort(journal, -error);

fs/ext4/super.c

721

if (continue_fs && journal &&

fs/ext4/super.c

755

journal_t *journal = sbi->s_journal;

fs/ext4/super.c

767

!sb_rdonly(sbi->s_sb) && journal) {

fs/ext4/super.c

771

handle = jbd2_journal_start(journal, 1);

fs/f2fs/checkpoint.c

1788

seg_i->journal->info.kbytes_written = cpu_to_le64(kbytes_written);

fs/f2fs/f2fs.h

2916

struct f2fs_journal *journal, unsigned int size, int type)

fs/f2fs/f2fs.h

2919

return size <= MAX_NAT_JENTRIES(sbi, journal);

fs/f2fs/f2fs.h

2920

return size <= MAX_SIT_JENTRIES(sbi, journal);

fs/f2fs/f2fs.h

4071

struct f2fs_journal *journal, int type,

fs/f2fs/f2fs.h

579

static inline int update_nats_in_cursum(struct f2fs_journal *journal, int i)

fs/f2fs/f2fs.h

581

int before = nats_in_cursum(journal);

fs/f2fs/f2fs.h

583

journal->n_nats = cpu_to_le16(before + i);

fs/f2fs/f2fs.h

587

static inline int update_sits_in_cursum(struct f2fs_journal *journal, int i)

fs/f2fs/f2fs.h

589

int before = sits_in_cursum(journal);

fs/f2fs/f2fs.h

591

journal->n_sits = cpu_to_le16(before + i);

fs/f2fs/node.c

2546

struct f2fs_journal *journal = curseg->journal;

fs/f2fs/node.c

2550

for (i = 0; i < nats_in_cursum(journal); i++) {

fs/f2fs/node.c

2554

addr = le32_to_cpu(nat_in_journal(journal, i).block_addr);

fs/f2fs/node.c

2555

nid = le32_to_cpu(nid_in_journal(journal, i));

fs/f2fs/node.c

3027

struct f2fs_journal *journal = curseg->journal;

fs/f2fs/node.c

3032

for (i = 0; i < nats_in_cursum(journal); i++) {

fs/f2fs/node.c

3035

nid_t nid = le32_to_cpu(nid_in_journal(journal, i));

fs/f2fs/node.c

3042

raw_ne = nat_in_journal(journal, i);

fs/f2fs/node.c

3065

update_nats_in_cursum(journal, -i);

fs/f2fs/node.c

3123

struct f2fs_journal *journal = curseg->journal;

fs/f2fs/node.c

3136

!__has_cursum_space(sbi, journal, set->entry_cnt, NAT_JOURNAL))

fs/f2fs/node.c

3159

offset = f2fs_lookup_journal_in_cursum(sbi, journal,

fs/f2fs/node.c

3162

raw_ne = &nat_in_journal(journal, offset);

fs/f2fs/node.c

3163

nid_in_journal(journal, offset) = cpu_to_le32(nid);

fs/f2fs/node.c

3201

struct f2fs_journal *journal = curseg->journal;

fs/f2fs/node.c

3230

!__has_cursum_space(sbi, journal,

fs/f2fs/node.c

3241

MAX_NAT_JENTRIES(sbi, journal));

fs/f2fs/node.c

3251

__has_cursum_space(sbi, journal,

fs/f2fs/node.c

575

struct f2fs_journal *journal = curseg->journal;

fs/f2fs/node.c

617

i = f2fs_lookup_journal_in_cursum(sbi, journal, NAT_JOURNAL, nid, 0);

fs/f2fs/node.c

619

ne = nat_in_journal(journal, i);

fs/f2fs/segment.c

2743

memcpy(sum_journal(sbi, dst), curseg->journal, sbi->sum_journal_size);

fs/f2fs/segment.c

4307

memcpy(seg_i->journal, kaddr, sbi->sum_journal_size);

fs/f2fs/segment.c

4311

memcpy(seg_i->journal, kaddr + sbi->sum_journal_size, sbi->sum_journal_size);

fs/f2fs/segment.c

4412

memcpy(curseg->journal, sum_journal(sbi, sum), sbi->sum_journal_size);

fs/f2fs/segment.c

4431

struct f2fs_journal *sit_j = CURSEG_I(sbi, CURSEG_COLD_DATA)->journal;

fs/f2fs/segment.c

4432

struct f2fs_journal *nat_j = CURSEG_I(sbi, CURSEG_HOT_DATA)->journal;

fs/f2fs/segment.c

4487

memcpy(kaddr, seg_i->journal, sbi->sum_journal_size);

fs/f2fs/segment.c

4492

memcpy(kaddr + written_size, seg_i->journal, sbi->sum_journal_size);

fs/f2fs/segment.c

4552

struct f2fs_journal *journal, int type,

fs/f2fs/segment.c

4558

for (i = 0; i < nats_in_cursum(journal); i++) {

fs/f2fs/segment.c

4559

if (le32_to_cpu(nid_in_journal(journal, i)) == val)

fs/f2fs/segment.c

4562

if (alloc && __has_cursum_space(sbi, journal, 1, NAT_JOURNAL))

fs/f2fs/segment.c

4563

return update_nats_in_cursum(journal, 1);

fs/f2fs/segment.c

4565

for (i = 0; i < sits_in_cursum(journal); i++)

fs/f2fs/segment.c

4566

if (le32_to_cpu(segno_in_journal(journal, i)) == val)

fs/f2fs/segment.c

4568

if (alloc && __has_cursum_space(sbi, journal, 1, SIT_JOURNAL))

fs/f2fs/segment.c

4569

return update_sits_in_cursum(journal, 1);

fs/f2fs/segment.c

4667

struct f2fs_journal *journal = curseg->journal;

fs/f2fs/segment.c

4671

for (i = 0; i < sits_in_cursum(journal); i++) {

fs/f2fs/segment.c

4675

segno = le32_to_cpu(segno_in_journal(journal, i));

fs/f2fs/segment.c

4681

update_sits_in_cursum(journal, -i);

fs/f2fs/segment.c

4694

struct f2fs_journal *journal = curseg->journal;

fs/f2fs/segment.c

4716

if (!__has_cursum_space(sbi, journal,

fs/f2fs/segment.c

4734

!__has_cursum_space(sbi, journal, ses->entry_cnt,

fs/f2fs/segment.c

4758

offset = f2fs_lookup_journal_in_cursum(sbi, journal,

fs/f2fs/segment.c

4761

segno_in_journal(journal, offset) =

fs/f2fs/segment.c

4764

&sit_in_journal(journal, offset));

fs/f2fs/segment.c

4766

&sit_in_journal(journal, offset));

fs/f2fs/segment.c

4954

array[i].journal = f2fs_kzalloc(sbi,

fs/f2fs/segment.c

4956

if (!array[i].journal)

fs/f2fs/segment.c

4968

struct f2fs_journal *journal = curseg->journal;

fs/f2fs/segment.c

5033

for (i = 0; i < sits_in_cursum(journal); i++) {

fs/f2fs/segment.c

5036

start = le32_to_cpu(segno_in_journal(journal, i));

fs/f2fs/segment.c

5046

sit = sit_in_journal(journal, i);

fs/f2fs/segment.c

5808

kfree(array[i].journal);

fs/f2fs/segment.h

271

struct f2fs_journal *journal; /* cached journal info */

fs/f2fs/super.c

5260

le64_to_cpu(seg_i->journal->info.kbytes_written);

fs/jbd2/checkpoint.c

104

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/checkpoint.c

105

jbd2_log_wait_commit(journal, tid);

fs/jbd2/checkpoint.c

106

write_lock(&journal->j_state_lock);

fs/jbd2/checkpoint.c

114

journal->j_devname);

fs/jbd2/checkpoint.c

116

jbd2_journal_abort(journal, -ENOSPC);

fs/jbd2/checkpoint.c

118

write_lock(&journal->j_state_lock);

fs/jbd2/checkpoint.c

120

spin_unlock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

122

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/checkpoint.c

127

__flush_batch(journal_t *journal, int *batch_count)

fs/jbd2/checkpoint.c

134

write_dirty_buffer(journal->j_chkpt_bhs[i], JBD2_JOURNAL_REQ_FLAGS);

fs/jbd2/checkpoint.c

138

struct buffer_head *bh = journal->j_chkpt_bhs[i];

fs/jbd2/checkpoint.c

141

journal->j_chkpt_bhs[i] = NULL;

fs/jbd2/checkpoint.c

154

int jbd2_log_do_checkpoint(journal_t *journal)

fs/jbd2/checkpoint.c

169

result = jbd2_cleanup_journal_tail(journal);

fs/jbd2/checkpoint.c

170

trace_jbd2_checkpoint(journal, result);

fs/jbd2/checkpoint.c

179

spin_lock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

180

if (!journal->j_checkpoint_transactions)

fs/jbd2/checkpoint.c

182

transaction = journal->j_checkpoint_transactions;

fs/jbd2/checkpoint.c

192

if (journal->j_checkpoint_transactions != transaction ||

fs/jbd2/checkpoint.c

206

spin_unlock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

207

if (unlikely(journal->j_flags & JBD2_UNMOUNT))

fs/jbd2/checkpoint.c

216

journal->j_devname, (unsigned long long) bh->b_blocknr);

fs/jbd2/checkpoint.c

219

__flush_batch(journal, &batch_count);

fs/jbd2/checkpoint.c

220

jbd2_log_start_commit(journal, tid);

fs/jbd2/checkpoint.c

229

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/checkpoint.c

230

jbd2_log_wait_commit(journal, tid);

fs/jbd2/checkpoint.c

231

mutex_lock_io(&journal->j_checkpoint_mutex);

fs/jbd2/checkpoint.c

232

spin_lock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

243

spin_unlock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

272

spin_unlock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

275

__flush_batch(journal, &batch_count);

fs/jbd2/checkpoint.c

276

jbd2_journal_abort(journal, -EFSCORRUPTED);

fs/jbd2/checkpoint.c

279

journal->j_chkpt_bhs[batch_count++] = bh;

fs/jbd2/checkpoint.c

285

need_resched() || spin_needbreak(&journal->j_list_lock) ||

fs/jbd2/checkpoint.c

286

jh2bh(transaction->t_checkpoint_list) == journal->j_chkpt_bhs[0])

fs/jbd2/checkpoint.c

292

spin_unlock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

295

__flush_batch(journal, &batch_count);

fs/jbd2/checkpoint.c

297

spin_lock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

302

spin_unlock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

303

result = jbd2_cleanup_journal_tail(journal);

fs/jbd2/checkpoint.c

326

int jbd2_cleanup_journal_tail(journal_t *journal)

fs/jbd2/checkpoint.c

331

if (is_journal_aborted(journal))

fs/jbd2/checkpoint.c

334

if (!jbd2_journal_get_log_tail(journal, &first_tid, &blocknr))

fs/jbd2/checkpoint.c

337

jbd2_journal_abort(journal, -EFSCORRUPTED);

fs/jbd2/checkpoint.c

349

if (journal->j_flags & JBD2_BARRIER)

fs/jbd2/checkpoint.c

350

blkdev_issue_flush(journal->j_fs_dev);

fs/jbd2/checkpoint.c

352

return __jbd2_update_log_tail(journal, first_tid, blocknr);

fs/jbd2/checkpoint.c

419

unsigned long jbd2_journal_shrink_checkpoint_list(journal_t *journal,

fs/jbd2/checkpoint.c

431

spin_lock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

432

if (!journal->j_checkpoint_transactions) {

fs/jbd2/checkpoint.c

433

spin_unlock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

443

if (journal->j_shrink_transaction)

fs/jbd2/checkpoint.c

444

transaction = journal->j_shrink_transaction;

fs/jbd2/checkpoint.c

446

transaction = journal->j_checkpoint_transactions;

fs/jbd2/checkpoint.c

452

last_transaction = journal->j_checkpoint_transactions->t_cpprev;

fs/jbd2/checkpoint.c

466

if (need_resched() || spin_needbreak(&journal->j_list_lock))

fs/jbd2/checkpoint.c

471

journal->j_shrink_transaction = next_transaction;

fs/jbd2/checkpoint.c

474

journal->j_shrink_transaction = NULL;

fs/jbd2/checkpoint.c

478

spin_unlock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

481

if (*nr_to_scan && journal->j_shrink_transaction)

fs/jbd2/checkpoint.c

484

trace_jbd2_shrink_checkpoint_list(journal, first_tid, tid, last_tid,

fs/jbd2/checkpoint.c

49

void __jbd2_log_wait_for_space(journal_t *journal)

fs/jbd2/checkpoint.c

50

__acquires(&journal->j_state_lock)

fs/jbd2/checkpoint.c

501

void __jbd2_journal_clean_checkpoint_list(journal_t *journal,

fs/jbd2/checkpoint.c

509

transaction = journal->j_checkpoint_transactions;

fs/jbd2/checkpoint.c

51

__releases(&journal->j_state_lock)

fs/jbd2/checkpoint.c

541

void jbd2_journal_destroy_checkpoint(journal_t *journal)

fs/jbd2/checkpoint.c

548

spin_lock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

549

if (!journal->j_checkpoint_transactions) {

fs/jbd2/checkpoint.c

550

spin_unlock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

553

__jbd2_journal_clean_checkpoint_list(journal, JBD2_SHRINK_DESTROY);

fs/jbd2/checkpoint.c

554

spin_unlock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

56

nblocks = journal->j_max_transaction_buffers;

fs/jbd2/checkpoint.c

57

while (jbd2_log_space_left(journal) < nblocks) {

fs/jbd2/checkpoint.c

58

write_unlock(&journal->j_state_lock);

fs/jbd2/checkpoint.c

581

journal_t *journal;

fs/jbd2/checkpoint.c

59

mutex_lock_io(&journal->j_checkpoint_mutex);

fs/jbd2/checkpoint.c

590

journal = transaction->t_journal;

fs/jbd2/checkpoint.c

596

percpu_counter_dec(&journal->j_checkpoint_jh_count);

fs/jbd2/checkpoint.c

623

trace_jbd2_checkpoint_stats(journal->j_fs_dev->bd_dev,

fs/jbd2/checkpoint.c

626

__jbd2_journal_drop_transaction(journal, transaction);

fs/jbd2/checkpoint.c

702

void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transaction)

fs/jbd2/checkpoint.c

704

assert_spin_locked(&journal->j_list_lock);

fs/jbd2/checkpoint.c

706

journal->j_shrink_transaction = NULL;

fs/jbd2/checkpoint.c

710

if (journal->j_checkpoint_transactions == transaction)

fs/jbd2/checkpoint.c

711

journal->j_checkpoint_transactions =

fs/jbd2/checkpoint.c

713

if (journal->j_checkpoint_transactions == transaction)

fs/jbd2/checkpoint.c

714

journal->j_checkpoint_transactions = NULL;

fs/jbd2/checkpoint.c

72

write_lock(&journal->j_state_lock);

fs/jbd2/checkpoint.c

723

J_ASSERT(journal->j_committing_transaction != transaction);

fs/jbd2/checkpoint.c

724

J_ASSERT(journal->j_running_transaction != transaction);

fs/jbd2/checkpoint.c

726

trace_jbd2_drop_transaction(journal, transaction);

fs/jbd2/checkpoint.c

73

if (journal->j_flags & JBD2_ABORT) {

fs/jbd2/checkpoint.c

74

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/checkpoint.c

77

spin_lock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

78

space_left = jbd2_log_space_left(journal);

fs/jbd2/checkpoint.c

80

int chkpt = journal->j_checkpoint_transactions != NULL;

fs/jbd2/checkpoint.c

84

if (journal->j_committing_transaction) {

fs/jbd2/checkpoint.c

85

tid = journal->j_committing_transaction->t_tid;

fs/jbd2/checkpoint.c

88

spin_unlock(&journal->j_list_lock);

fs/jbd2/checkpoint.c

89

write_unlock(&journal->j_state_lock);

fs/jbd2/checkpoint.c

91

jbd2_log_do_checkpoint(journal);

fs/jbd2/checkpoint.c

92

} else if (jbd2_cleanup_journal_tail(journal) <= 0) {

fs/jbd2/commit.c

1043

if (is_journal_aborted(journal))

fs/jbd2/commit.c

1068

cond_resched_lock(&journal->j_list_lock);

fs/jbd2/commit.c

1070

spin_unlock(&journal->j_list_lock);

fs/jbd2/commit.c

1077

write_lock(&journal->j_state_lock);

fs/jbd2/commit.c

1078

spin_lock(&journal->j_list_lock);

fs/jbd2/commit.c

1084

spin_unlock(&journal->j_list_lock);

fs/jbd2/commit.c

1085

write_unlock(&journal->j_state_lock);

fs/jbd2/commit.c

1092

if (journal->j_checkpoint_transactions == NULL) {

fs/jbd2/commit.c

1093

journal->j_checkpoint_transactions = commit_transaction;

fs/jbd2/commit.c

1098

journal->j_checkpoint_transactions;

fs/jbd2/commit.c

1106

spin_unlock(&journal->j_list_lock);

fs/jbd2/commit.c

1124

trace_jbd2_run_stats(journal->j_fs_dev->bd_dev,

fs/jbd2/commit.c

1129

J_ASSERT(commit_transaction == journal->j_committing_transaction);

fs/jbd2/commit.c

1130

WRITE_ONCE(journal->j_commit_sequence, commit_transaction->t_tid);

fs/jbd2/commit.c

1131

journal->j_committing_transaction = NULL;

fs/jbd2/commit.c

1138

if (likely(journal->j_average_commit_time))

fs/jbd2/commit.c

1139

journal->j_average_commit_time = (commit_time +

fs/jbd2/commit.c

114

static int journal_submit_commit_record(journal_t *journal,

fs/jbd2/commit.c

1140

journal->j_average_commit_time*3) / 4;

fs/jbd2/commit.c

1142

journal->j_average_commit_time = commit_time;

fs/jbd2/commit.c

1144

write_unlock(&journal->j_state_lock);

fs/jbd2/commit.c

1146

if (journal->j_commit_callback)

fs/jbd2/commit.c

1147

journal->j_commit_callback(journal, commit_transaction);

fs/jbd2/commit.c

1148

if (journal->j_fc_cleanup_callback)

fs/jbd2/commit.c

1149

journal->j_fc_cleanup_callback(journal, 1, commit_transaction->t_tid);

fs/jbd2/commit.c

1151

trace_jbd2_end_commit(journal, commit_transaction);

fs/jbd2/commit.c

1153

journal->j_commit_sequence, journal->j_tail_sequence);

fs/jbd2/commit.c

1155

write_lock(&journal->j_state_lock);

fs/jbd2/commit.c

1156

journal->j_flags &= ~JBD2_FULL_COMMIT_ONGOING;

fs/jbd2/commit.c

1157

journal->j_flags &= ~JBD2_FAST_COMMIT_ONGOING;

fs/jbd2/commit.c

1158

spin_lock(&journal->j_list_lock);

fs/jbd2/commit.c

1162

__jbd2_journal_drop_transaction(journal, commit_transaction);

fs/jbd2/commit.c

1165

spin_unlock(&journal->j_list_lock);

fs/jbd2/commit.c

1166

write_unlock(&journal->j_state_lock);

fs/jbd2/commit.c

1167

wake_up(&journal->j_wait_done_commit);

fs/jbd2/commit.c

1168

wake_up(&journal->j_fc_wait);

fs/jbd2/commit.c

1173

spin_lock(&journal->j_history_lock);

fs/jbd2/commit.c

1174

journal->j_stats.ts_tid++;

fs/jbd2/commit.c

1175

journal->j_stats.ts_requested += stats.ts_requested;

fs/jbd2/commit.c

1176

journal->j_stats.run.rs_wait += stats.run.rs_wait;

fs/jbd2/commit.c

1177

journal->j_stats.run.rs_request_delay += stats.run.rs_request_delay;

fs/jbd2/commit.c

1178

journal->j_stats.run.rs_running += stats.run.rs_running;

fs/jbd2/commit.c

1179

journal->j_stats.run.rs_locked += stats.run.rs_locked;

fs/jbd2/commit.c

1180

journal->j_stats.run.rs_flushing += stats.run.rs_flushing;

fs/jbd2/commit.c

1181

journal->j_stats.run.rs_logging += stats.run.rs_logging;

fs/jbd2/commit.c

1182

journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count;

fs/jbd2/commit.c

1183

journal->j_stats.run.rs_blocks += stats.run.rs_blocks;

fs/jbd2/commit.c

1184

journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;

fs/jbd2/commit.c

1185

spin_unlock(&journal->j_history_lock);

fs/jbd2/commit.c

126

if (is_journal_aborted(journal))

fs/jbd2/commit.c

139

if (jbd2_has_feature_checksum(journal)) {

fs/jbd2/commit.c

144

jbd2_commit_block_csum_set(journal, bh);

fs/jbd2/commit.c

151

if (journal->j_flags & JBD2_BARRIER &&

fs/jbd2/commit.c

152

!jbd2_has_feature_async_commit(journal))

fs/jbd2/commit.c

164

static int journal_wait_on_commit_record(journal_t *journal,

fs/jbd2/commit.c

180

int jbd2_submit_inode_data(journal_t *journal, struct jbd2_inode *jinode)

fs/jbd2/commit.c

192

return journal->j_submit_inode_data_buffers(jinode);

fs/jbd2/commit.c

197

int jbd2_wait_inode_data(journal_t *journal, struct jbd2_inode *jinode)

fs/jbd2/commit.c

234

static int journal_submit_data_buffers(journal_t *journal,

fs/jbd2/commit.c

240

spin_lock(&journal->j_list_lock);

fs/jbd2/commit.c

246

spin_unlock(&journal->j_list_lock);

fs/jbd2/commit.c

249

if (journal->j_submit_inode_data_buffers) {

fs/jbd2/commit.c

250

err = journal->j_submit_inode_data_buffers(jinode);

fs/jbd2/commit.c

254

spin_lock(&journal->j_list_lock);

fs/jbd2/commit.c

261

spin_unlock(&journal->j_list_lock);

fs/jbd2/commit.c

282

static int journal_finish_inode_data_buffers(journal_t *journal,

fs/jbd2/commit.c

289

spin_lock(&journal->j_list_lock);

fs/jbd2/commit.c

294

spin_unlock(&journal->j_list_lock);

fs/jbd2/commit.c

296

if (journal->j_finish_inode_data_buffers) {

fs/jbd2/commit.c

297

err = journal->j_finish_inode_data_buffers(jinode);

fs/jbd2/commit.c

302

spin_lock(&journal->j_list_lock);

fs/jbd2/commit.c

323

spin_unlock(&journal->j_list_lock);

fs/jbd2/commit.c

376

void jbd2_journal_commit_transaction(journal_t *journal)

fs/jbd2/commit.c

382

struct buffer_head **wbuf = journal->j_wbuf;

fs/jbd2/commit.c

395

int tag_bytes = journal_tag_bytes(journal);

fs/jbd2/commit.c

407

if (jbd2_journal_has_csum_v2or3(journal))

fs/jbd2/commit.c

416

if (journal->j_flags & JBD2_FLUSHED) {

fs/jbd2/commit.c

418

mutex_lock_io(&journal->j_checkpoint_mutex);

fs/jbd2/commit.c

425

jbd2_journal_update_sb_log_tail(journal,

fs/jbd2/commit.c

426

journal->j_tail_sequence,

fs/jbd2/commit.c

427

journal->j_tail, 0);

fs/jbd2/commit.c

428

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/commit.c

433

J_ASSERT(journal->j_running_transaction != NULL);

fs/jbd2/commit.c

434

J_ASSERT(journal->j_committing_transaction == NULL);

fs/jbd2/commit.c

436

write_lock(&journal->j_state_lock);

fs/jbd2/commit.c

437

journal->j_flags |= JBD2_FULL_COMMIT_ONGOING;

fs/jbd2/commit.c

438

while (journal->j_flags & JBD2_FAST_COMMIT_ONGOING) {

fs/jbd2/commit.c

441

prepare_to_wait(&journal->j_fc_wait, &wait,

fs/jbd2/commit.c

443

write_unlock(&journal->j_state_lock);

fs/jbd2/commit.c

445

write_lock(&journal->j_state_lock);

fs/jbd2/commit.c

446

finish_wait(&journal->j_fc_wait, &wait);

fs/jbd2/commit.c

457

write_unlock(&journal->j_state_lock);

fs/jbd2/commit.c

459

commit_transaction = journal->j_running_transaction;

fs/jbd2/commit.c

461

trace_jbd2_start_commit(journal, commit_transaction);

fs/jbd2/commit.c

465

write_lock(&journal->j_state_lock);

fs/jbd2/commit.c

466

journal->j_fc_off = 0;

fs/jbd2/commit.c

470

trace_jbd2_commit_locking(journal, commit_transaction);

fs/jbd2/commit.c

482

jbd2_journal_wait_updates(journal);

fs/jbd2/commit.c

487

journal->j_max_transaction_buffers);

fs/jbd2/commit.c

520

jbd2_journal_refile_buffer(journal, jh);

fs/jbd2/commit.c

523

write_unlock(&journal->j_state_lock);

fs/jbd2/commit.c

529

spin_lock(&journal->j_list_lock);

fs/jbd2/commit.c

530

__jbd2_journal_clean_checkpoint_list(journal, JBD2_SHRINK_BUSY_STOP);

fs/jbd2/commit.c

531

spin_unlock(&journal->j_list_lock);

fs/jbd2/commit.c

539

jbd2_clear_buffer_revoked_flags(journal);

fs/jbd2/commit.c

544

jbd2_journal_switch_revoke_table(journal);

fs/jbd2/commit.c

546

write_lock(&journal->j_state_lock);

fs/jbd2/commit.c

550

atomic_sub(atomic_read(&journal->j_reserved_credits),

fs/jbd2/commit.c

553

trace_jbd2_commit_flushing(journal, commit_transaction);

fs/jbd2/commit.c

559

journal->j_committing_transaction = commit_transaction;

fs/jbd2/commit.c

560

journal->j_running_transaction = NULL;

fs/jbd2/commit.c

562

commit_transaction->t_log_start = journal->j_head;

fs/jbd2/commit.c

563

wake_up_all(&journal->j_wait_transaction_locked);

fs/jbd2/commit.c

564

write_unlock(&journal->j_state_lock);

fs/jbd2/commit.c

572

err = journal_submit_data_buffers(journal, commit_transaction);

fs/jbd2/commit.c

574

jbd2_journal_abort(journal, err);

fs/jbd2/commit.c

586

write_lock(&journal->j_state_lock);

fs/jbd2/commit.c

588

write_unlock(&journal->j_state_lock);

fs/jbd2/commit.c

590

trace_jbd2_commit_logging(journal, commit_transaction);

fs/jbd2/commit.c

611

if (is_journal_aborted(journal)) {

fs/jbd2/commit.c

618

jbd2_journal_refile_buffer(journal, jh);

fs/jbd2/commit.c

640

jbd2_journal_abort(journal, -EIO);

fs/jbd2/commit.c

663

err = jbd2_journal_next_log_block(journal, &blocknr);

fs/jbd2/commit.c

668

jbd2_journal_abort(journal, err);

fs/jbd2/commit.c

703

write_tag_block(journal, tag, jh2bh(jh)->b_blocknr);

fs/jbd2/commit.c

705

jbd2_block_tag_csum_set(journal, tag, wbuf[bufs],

fs/jbd2/commit.c

712

memcpy (tagp, journal->j_uuid, 16);

fs/jbd2/commit.c

721

if (bufs == journal->j_wbufsize ||

fs/jbd2/commit.c

734

jbd2_descriptor_block_csum_set(journal,

fs/jbd2/commit.c

743

if (jbd2_has_feature_checksum(journal)) {

fs/jbd2/commit.c

764

err = journal_finish_inode_data_buffers(journal, commit_transaction);

fs/jbd2/commit.c

768

err, journal->j_devname);

fs/jbd2/commit.c

780

jbd2_journal_get_log_tail(journal, &first_tid, &first_block);

fs/jbd2/commit.c

782

write_lock(&journal->j_state_lock);

fs/jbd2/commit.c

784

long freed = first_block - journal->j_tail;

fs/jbd2/commit.c

786

if (first_block < journal->j_tail)

fs/jbd2/commit.c

787

freed += journal->j_last - journal->j_first;

fs/jbd2/commit.c

789

if (freed < journal->j_max_transaction_buffers)

fs/jbd2/commit.c

794

write_unlock(&journal->j_state_lock);

fs/jbd2/commit.c

802

(journal->j_fs_dev != journal->j_dev) &&

fs/jbd2/commit.c

803

(journal->j_flags & JBD2_BARRIER))

fs/jbd2/commit.c

804

blkdev_issue_flush(journal->j_fs_dev);

fs/jbd2/commit.c

807

if (jbd2_has_feature_async_commit(journal)) {

fs/jbd2/commit.c

808

err = journal_submit_commit_record(journal, commit_transaction,

fs/jbd2/commit.c

811

jbd2_journal_abort(journal, err);

fs/jbd2/commit.c

892

jbd2_journal_abort(journal, err);

fs/jbd2/commit.c

895

write_lock(&journal->j_state_lock);

fs/jbd2/commit.c

898

write_unlock(&journal->j_state_lock);

fs/jbd2/commit.c

900

if (!jbd2_has_feature_async_commit(journal)) {

fs/jbd2/commit.c

901

err = journal_submit_commit_record(journal, commit_transaction,

fs/jbd2/commit.c

904

jbd2_journal_abort(journal, err);

fs/jbd2/commit.c

907

err = journal_wait_on_commit_record(journal, cbh);

fs/jbd2/commit.c

909

if (jbd2_has_feature_async_commit(journal) &&

fs/jbd2/commit.c

910

journal->j_flags & JBD2_BARRIER) {

fs/jbd2/commit.c

911

blkdev_issue_flush(journal->j_dev);

fs/jbd2/commit.c

915

jbd2_journal_abort(journal, err);

fs/jbd2/commit.c

926

jbd2_update_log_tail(journal, first_tid, first_block);

fs/jbd2/commit.c

945

spin_lock(&journal->j_list_lock);

fs/jbd2/commit.c

953

spin_unlock(&journal->j_list_lock);

fs/jbd2/commit.c

990

spin_lock(&journal->j_list_lock);

fs/jbd2/journal.c

1015

int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,

fs/jbd2/journal.c

1021

read_lock(&journal->j_state_lock);

fs/jbd2/journal.c

1022

spin_lock(&journal->j_list_lock);

fs/jbd2/journal.c

1023

transaction = journal->j_checkpoint_transactions;

fs/jbd2/journal.c

1027

} else if ((transaction = journal->j_committing_transaction) != NULL) {

fs/jbd2/journal.c

1030

} else if ((transaction = journal->j_running_transaction) != NULL) {

fs/jbd2/journal.c

1032

*block = journal->j_head;

fs/jbd2/journal.c

1034

*tid = journal->j_transaction_sequence;

fs/jbd2/journal.c

1035

*block = journal->j_head;

fs/jbd2/journal.c

1037

ret = tid_gt(*tid, journal->j_tail_sequence);

fs/jbd2/journal.c

1038

spin_unlock(&journal->j_list_lock);

fs/jbd2/journal.c

1039

read_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

1054

int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)

fs/jbd2/journal.c

1059

BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));

fs/jbd2/journal.c

1067

ret = jbd2_journal_update_sb_log_tail(journal, tid, block, REQ_FUA);

fs/jbd2/journal.c

1071

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

1072

freed = block - journal->j_tail;

fs/jbd2/journal.c

1073

if (block < journal->j_tail)

fs/jbd2/journal.c

1074

freed += journal->j_last - journal->j_first;

fs/jbd2/journal.c

1076

trace_jbd2_update_log_tail(journal, tid, block, freed);

fs/jbd2/journal.c

1080

journal->j_tail_sequence, tid, block, freed);

fs/jbd2/journal.c

1082

journal->j_free += freed;

fs/jbd2/journal.c

1083

journal->j_tail_sequence = tid;

fs/jbd2/journal.c

1084

journal->j_tail = block;

fs/jbd2/journal.c

1085

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

1096

void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)

fs/jbd2/journal.c

1098

mutex_lock_io(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

1099

if (tid_gt(tid, journal->j_tail_sequence))

fs/jbd2/journal.c

1100

__jbd2_update_log_tail(journal, tid, block);

fs/jbd2/journal.c

1101

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

1105

journal_t *journal;

fs/jbd2/journal.c

1131

s->journal->j_max_transaction_buffers);

fs/jbd2/journal.c

1149

div_u64(s->journal->j_average_commit_time, 1000));

fs/jbd2/journal.c

1172

journal_t *journal = pde_data(inode);

fs/jbd2/journal.c

1185

spin_lock(&journal->j_history_lock);

fs/jbd2/journal.c

1186

memcpy(s->stats, &journal->j_stats, size);

fs/jbd2/journal.c

1187

s->journal = journal;

fs/jbd2/journal.c

1188

spin_unlock(&journal->j_history_lock);

fs/jbd2/journal.c

1220

static void jbd2_stats_proc_init(journal_t *journal)

fs/jbd2/journal.c

1222

journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);

fs/jbd2/journal.c

1223

if (journal->j_proc_entry) {

fs/jbd2/journal.c

1224

proc_create_data("info", S_IRUGO, journal->j_proc_entry,

fs/jbd2/journal.c

1225

&jbd2_info_proc_ops, journal);

fs/jbd2/journal.c

1229

static void jbd2_stats_proc_exit(journal_t *journal)

fs/jbd2/journal.c

1231

remove_proc_entry("info", journal->j_proc_entry);

fs/jbd2/journal.c

1232

remove_proc_entry(journal->j_devname, proc_jbd2_stats);

fs/jbd2/journal.c

1256

journal_t *journal = shrink->private_data;

fs/jbd2/journal.c

1261

count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count);

fs/jbd2/journal.c

1262

trace_jbd2_shrink_scan_enter(journal, sc->nr_to_scan, count);

fs/jbd2/journal.c

1264

nr_shrunk = jbd2_journal_shrink_checkpoint_list(journal, &nr_to_scan);

fs/jbd2/journal.c

1266

count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count);

fs/jbd2/journal.c

1267

trace_jbd2_shrink_scan_exit(journal, nr_to_scan, nr_shrunk, count);

fs/jbd2/journal.c

1282

journal_t *journal = shrink->private_data;

fs/jbd2/journal.c

1285

count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count);

fs/jbd2/journal.c

1286

trace_jbd2_shrink_count(journal, sc->nr_to_scan, count);

fs/jbd2/journal.c

1296

static void journal_fail_superblock(journal_t *journal)

fs/jbd2/journal.c

1298

struct buffer_head *bh = journal->j_sb_buffer;

fs/jbd2/journal.c

1300

journal->j_sb_buffer = NULL;

fs/jbd2/journal.c

1307

static int journal_check_superblock(journal_t *journal)

fs/jbd2/journal.c

1309

journal_superblock_t *sb = journal->j_superblock;

fs/jbd2/journal.c

1314

sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {

fs/jbd2/journal.c

1325

if (be32_to_cpu(sb->s_maxlen) > journal->j_total_len) {

fs/jbd2/journal.c

1331

be32_to_cpu(sb->s_first) >= journal->j_total_len) {

fs/jbd2/journal.c

1342

if (!jbd2_format_support_feature(journal))

fs/jbd2/journal.c

135

journal_t *journal = timer_container_of(journal, t, j_commit_timer);

fs/jbd2/journal.c

1353

num_fc_blks = jbd2_has_feature_fast_commit(journal) ?

fs/jbd2/journal.c

1362

if (jbd2_has_feature_csum2(journal) &&

fs/jbd2/journal.c

1363

jbd2_has_feature_csum3(journal)) {

fs/jbd2/journal.c

137

wake_up_process(journal->j_task);

fs/jbd2/journal.c

1370

if (jbd2_journal_has_csum_v2or3(journal) &&

fs/jbd2/journal.c

1371

jbd2_has_feature_checksum(journal)) {

fs/jbd2/journal.c

1378

if (jbd2_journal_has_csum_v2or3(journal)) {

fs/jbd2/journal.c

1395

static int journal_revoke_records_per_block(journal_t *journal)

fs/jbd2/journal.c

1398

int space = journal->j_blocksize - sizeof(jbd2_journal_revoke_header_t);

fs/jbd2/journal.c

1400

if (jbd2_has_feature_64bit(journal))

fs/jbd2/journal.c

1405

if (jbd2_journal_has_csum_v2or3(journal))

fs/jbd2/journal.c

1410

static int jbd2_journal_get_max_txn_bufs(journal_t *journal)

fs/jbd2/journal.c

1412

return (journal->j_total_len - journal->j_fc_wbufsize) / 3;

fs/jbd2/journal.c

1418

static int jbd2_descriptor_blocks_per_trans(journal_t *journal)

fs/jbd2/journal.c

1420

int tag_space = journal->j_blocksize - sizeof(journal_header_t);

fs/jbd2/journal.c

1425

if (jbd2_journal_has_csum_v2or3(journal))

fs/jbd2/journal.c

1428

tags_per_block = (tag_space - 16) / journal_tag_bytes(journal);

fs/jbd2/journal.c

1433

return 1 + DIV_ROUND_UP(jbd2_journal_get_max_txn_bufs(journal),

fs/jbd2/journal.c

1442

static void jbd2_journal_init_transaction_limits(journal_t *journal)

fs/jbd2/journal.c

1444

journal->j_revoke_records_per_block =

fs/jbd2/journal.c

1445

journal_revoke_records_per_block(journal);

fs/jbd2/journal.c

1446

journal->j_transaction_overhead_buffers =

fs/jbd2/journal.c

1447

jbd2_descriptor_blocks_per_trans(journal);

fs/jbd2/journal.c

1448

journal->j_max_transaction_buffers =

fs/jbd2/journal.c

1449

jbd2_journal_get_max_txn_bufs(journal);

fs/jbd2/journal.c

1456

static int journal_load_superblock(journal_t *journal)

fs/jbd2/journal.c

1462

bh = getblk_unmovable(journal->j_dev, journal->j_blk_offset,

fs/jbd2/journal.c

1463

journal->j_blocksize);

fs/jbd2/journal.c

1472

journal->j_sb_buffer = bh;

fs/jbd2/journal.c

1474

journal->j_superblock = sb;

fs/jbd2/journal.c

1475

err = journal_check_superblock(journal);

fs/jbd2/journal.c

1477

journal_fail_superblock(journal);

fs/jbd2/journal.c

1481

journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);

fs/jbd2/journal.c

1482

journal->j_tail = be32_to_cpu(sb->s_start);

fs/jbd2/journal.c

1483

journal->j_first = be32_to_cpu(sb->s_first);

fs/jbd2/journal.c

1484

journal->j_errno = be32_to_cpu(sb->s_errno);

fs/jbd2/journal.c

1485

journal->j_last = be32_to_cpu(sb->s_maxlen);

fs/jbd2/journal.c

1487

if (be32_to_cpu(sb->s_maxlen) < journal->j_total_len)

fs/jbd2/journal.c

1488

journal->j_total_len = be32_to_cpu(sb->s_maxlen);

fs/jbd2/journal.c

1490

if (jbd2_journal_has_csum_v2or3(journal))

fs/jbd2/journal.c

1491

journal->j_csum_seed = jbd2_chksum(~0, sb->s_uuid,

fs/jbd2/journal.c

1494

jbd2_journal_init_transaction_limits(journal);

fs/jbd2/journal.c

1496

if (jbd2_has_feature_fast_commit(journal)) {

fs/jbd2/journal.c

1497

journal->j_fc_last = be32_to_cpu(sb->s_maxlen);

fs/jbd2/journal.c

1498

journal->j_last = journal->j_fc_last -

fs/jbd2/journal.c

1500

journal->j_fc_first = journal->j_last + 1;

fs/jbd2/journal.c

1501

journal->j_fc_off = 0;

fs/jbd2/journal.c

1522

journal_t *journal;

fs/jbd2/journal.c

1526

journal = kzalloc_obj(*journal);

fs/jbd2/journal.c

1527

if (!journal)

fs/jbd2/journal.c

1530

lockdep_register_key(&journal->jbd2_trans_commit_key);

fs/jbd2/journal.c

1531

journal->j_blocksize = blocksize;

fs/jbd2/journal.c

1532

journal->j_dev = bdev;

fs/jbd2/journal.c

1533

journal->j_fs_dev = fs_dev;

fs/jbd2/journal.c

1534

journal->j_blk_offset = start;

fs/jbd2/journal.c

1535

journal->j_total_len = len;

fs/jbd2/journal.c

1536

jbd2_init_fs_dev_write_error(journal);

fs/jbd2/journal.c

1538

err = journal_load_superblock(journal);

fs/jbd2/journal.c

1542

init_waitqueue_head(&journal->j_wait_transaction_locked);

fs/jbd2/journal.c

1543

init_waitqueue_head(&journal->j_wait_done_commit);

fs/jbd2/journal.c

1544

init_waitqueue_head(&journal->j_wait_commit);

fs/jbd2/journal.c

1545

init_waitqueue_head(&journal->j_wait_updates);

fs/jbd2/journal.c

1546

init_waitqueue_head(&journal->j_wait_reserved);

fs/jbd2/journal.c

1547

init_waitqueue_head(&journal->j_fc_wait);

fs/jbd2/journal.c

1548

mutex_init(&journal->j_abort_mutex);

fs/jbd2/journal.c

1549

mutex_init(&journal->j_barrier);

fs/jbd2/journal.c

1550

mutex_init(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

1551

spin_lock_init(&journal->j_revoke_lock);

fs/jbd2/journal.c

1552

spin_lock_init(&journal->j_list_lock);

fs/jbd2/journal.c

1553

spin_lock_init(&journal->j_history_lock);

fs/jbd2/journal.c

1554

rwlock_init(&journal->j_state_lock);

fs/jbd2/journal.c

1556

journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE);

fs/jbd2/journal.c

1557

journal->j_min_batch_time = 0;

fs/jbd2/journal.c

1558

journal->j_max_batch_time = 15000; /* 15ms */

fs/jbd2/journal.c

1559

atomic_set(&journal->j_reserved_credits, 0);

fs/jbd2/journal.c

1560

lockdep_init_map(&journal->j_trans_commit_map, "jbd2_handle",

fs/jbd2/journal.c

1561

&journal->jbd2_trans_commit_key, 0);

fs/jbd2/journal.c

1564

journal->j_flags = JBD2_ABORT;

fs/jbd2/journal.c

1567

err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);

fs/jbd2/journal.c

1576

n = journal->j_blocksize / jbd2_min_tag_size();

fs/jbd2/journal.c

1577

journal->j_wbufsize = n;

fs/jbd2/journal.c

1578

journal->j_fc_wbuf = NULL;

fs/jbd2/journal.c

1579

journal->j_wbuf = kmalloc_objs(struct buffer_head *, n);

fs/jbd2/journal.c

1580

if (!journal->j_wbuf)

fs/jbd2/journal.c

1583

err = percpu_counter_init(&journal->j_checkpoint_jh_count, 0,

fs/jbd2/journal.c

1588

journal->j_shrink_transaction = NULL;

fs/jbd2/journal.c

1590

journal->j_shrinker = shrinker_alloc(0, "jbd2-journal:(%u:%u)",

fs/jbd2/journal.c

1593

if (!journal->j_shrinker) {

fs/jbd2/journal.c

1598

journal->j_shrinker->scan_objects = jbd2_journal_shrink_scan;

fs/jbd2/journal.c

1599

journal->j_shrinker->count_objects = jbd2_journal_shrink_count;

fs/jbd2/journal.c

160

journal_t *journal = arg;

fs/jbd2/journal.c

1600

journal->j_shrinker->private_data = journal;

fs/jbd2/journal.c

1602

shrinker_register(journal->j_shrinker);

fs/jbd2/journal.c

1604

return journal;

fs/jbd2/journal.c

1607

percpu_counter_destroy(&journal->j_checkpoint_jh_count);

fs/jbd2/journal.c

1608

kfree(journal->j_wbuf);

fs/jbd2/journal.c

1609

jbd2_journal_destroy_revoke(journal);

fs/jbd2/journal.c

1610

journal_fail_superblock(journal);

fs/jbd2/journal.c

1611

lockdep_unregister_key(&journal->jbd2_trans_commit_key);

fs/jbd2/journal.c

1612

kfree(journal);

fs/jbd2/journal.c

1643

journal_t *journal;

fs/jbd2/journal.c

1645

journal = journal_init_common(bdev, fs_dev, start, len, blocksize);

fs/jbd2/journal.c

1646

if (IS_ERR(journal))

fs/jbd2/journal.c

1647

return ERR_CAST(journal);

fs/jbd2/journal.c

1649

snprintf(journal->j_devname, sizeof(journal->j_devname),

fs/jbd2/journal.c

1650

"%pg", journal->j_dev);

fs/jbd2/journal.c

1651

strreplace(journal->j_devname, '/', '!');

fs/jbd2/journal.c

1652

jbd2_stats_proc_init(journal);

fs/jbd2/journal.c

1654

return journal;

fs/jbd2/journal.c

1667

journal_t *journal;

fs/jbd2/journal.c

167

timer_setup(&journal->j_commit_timer, commit_timeout, 0);

fs/jbd2/journal.c

1682

journal = journal_init_common(inode->i_sb->s_bdev, inode->i_sb->s_bdev,

fs/jbd2/journal.c

1685

if (IS_ERR(journal))

fs/jbd2/journal.c

1686

return ERR_CAST(journal);

fs/jbd2/journal.c

1688

journal->j_inode = inode;

fs/jbd2/journal.c

1689

snprintf(journal->j_devname, sizeof(journal->j_devname),

fs/jbd2/journal.c

1690

"%pg-%llu", journal->j_dev, journal->j_inode->i_ino);

fs/jbd2/journal.c

1691

strreplace(journal->j_devname, '/', '!');

fs/jbd2/journal.c

1692

jbd2_stats_proc_init(journal);

fs/jbd2/journal.c

1694

return journal;

fs/jbd2/journal.c

1704

static int journal_reset(journal_t *journal)

fs/jbd2/journal.c

1706

journal_superblock_t *sb = journal->j_superblock;

fs/jbd2/journal.c

1714

journal_fail_superblock(journal);

fs/jbd2/journal.c

1718

journal->j_first = first;

fs/jbd2/journal.c

1719

journal->j_last = last;

fs/jbd2/journal.c

172

journal->j_task = current;

fs/jbd2/journal.c

1721

if (journal->j_head != 0 && journal->j_flags & JBD2_CYCLE_RECORD) {

fs/jbd2/journal.c

1726

if (journal->j_head < first || journal->j_head >= last) {

fs/jbd2/journal.c

1729

journal->j_head);

fs/jbd2/journal.c

173

wake_up(&journal->j_wait_done_commit);

fs/jbd2/journal.c

1730

journal->j_head = journal->j_first;

fs/jbd2/journal.c

1733

journal->j_head = journal->j_first;

fs/jbd2/journal.c

1735

journal->j_tail = journal->j_head;

fs/jbd2/journal.c

1736

journal->j_free = journal->j_last - journal->j_first;

fs/jbd2/journal.c

1738

journal->j_tail_sequence = journal->j_transaction_sequence;

fs/jbd2/journal.c

1739

journal->j_commit_sequence = journal->j_transaction_sequence - 1;

fs/jbd2/journal.c

1740

journal->j_commit_request = journal->j_commit_sequence;

fs/jbd2/journal.c

1747

jbd2_clear_feature_fast_commit(journal);

fs/jbd2/journal.c

1758

journal->j_tail, journal->j_tail_sequence,

fs/jbd2/journal.c

1759

journal->j_errno);

fs/jbd2/journal.c

1760

journal->j_flags |= JBD2_FLUSHED;

fs/jbd2/journal.c

1763

mutex_lock_io(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

1770

jbd2_journal_update_sb_log_tail(journal,

fs/jbd2/journal.c

1771

journal->j_tail_sequence,

fs/jbd2/journal.c

1772

journal->j_tail, REQ_FUA);

fs/jbd2/journal.c

1773

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

1775

return jbd2_journal_start_thread(journal);

fs/jbd2/journal.c

1782

static int jbd2_write_superblock(journal_t *journal, blk_opf_t write_flags)

fs/jbd2/journal.c

1784

struct buffer_head *bh = journal->j_sb_buffer;

fs/jbd2/journal.c

1785

journal_superblock_t *sb = journal->j_superblock;

fs/jbd2/journal.c

1799

if (!(journal->j_flags & JBD2_BARRIER))

fs/jbd2/journal.c

1802

trace_jbd2_write_superblock(journal, write_flags);

fs/jbd2/journal.c

1815

journal->j_devname);

fs/jbd2/journal.c

1819

if (jbd2_journal_has_csum_v2or3(journal))

fs/jbd2/journal.c

1830

journal->j_devname);

fs/jbd2/journal.c

1831

if (!is_journal_aborted(journal))

fs/jbd2/journal.c

1832

jbd2_journal_abort(journal, ret);

fs/jbd2/journal.c

1848

int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,

fs/jbd2/journal.c

1852

journal_superblock_t *sb = journal->j_superblock;

fs/jbd2/journal.c

1855

if (is_journal_aborted(journal))

fs/jbd2/journal.c

1857

ret = jbd2_check_fs_dev_write_error(journal);

fs/jbd2/journal.c

1859

jbd2_journal_abort(journal, ret);

fs/jbd2/journal.c

186

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

1863

BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));

fs/jbd2/journal.c

1867

lock_buffer(journal->j_sb_buffer);

fs/jbd2/journal.c

1871

ret = jbd2_write_superblock(journal, write_flags);

fs/jbd2/journal.c

1876

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

1877

journal->j_flags &= ~JBD2_FLUSHED;

fs/jbd2/journal.c

1878

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

189

if (journal->j_flags & JBD2_UNMOUNT)

fs/jbd2/journal.c

1892

static void jbd2_mark_journal_empty(journal_t *journal, blk_opf_t write_flags)

fs/jbd2/journal.c

1894

journal_superblock_t *sb = journal->j_superblock;

fs/jbd2/journal.c

1897

BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));

fs/jbd2/journal.c

1898

lock_buffer(journal->j_sb_buffer);

fs/jbd2/journal.c

1900

unlock_buffer(journal->j_sb_buffer);

fs/jbd2/journal.c

1905

journal->j_tail_sequence);

fs/jbd2/journal.c

1907

sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);

fs/jbd2/journal.c

1909

sb->s_head = cpu_to_be32(journal->j_head);

fs/jbd2/journal.c

1910

if (jbd2_has_feature_fast_commit(journal)) {

fs/jbd2/journal.c

1915

jbd2_clear_feature_fast_commit(journal);

fs/jbd2/journal.c

1919

jbd2_write_superblock(journal, write_flags);

fs/jbd2/journal.c

1922

jbd2_set_feature_fast_commit(journal);

fs/jbd2/journal.c

1925

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

1926

journal->j_flags |= JBD2_FLUSHED;

fs/jbd2/journal.c

1927

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

193

journal->j_commit_sequence, journal->j_commit_request);

fs/jbd2/journal.c

1942

static int __jbd2_journal_erase(journal_t *journal, unsigned int flags)

fs/jbd2/journal.c

195

if (journal->j_commit_sequence != journal->j_commit_request) {

fs/jbd2/journal.c

1956

!bdev_max_discard_sectors(journal->j_dev))

fs/jbd2/journal.c

1963

log_offset = be32_to_cpu(journal->j_superblock->s_first);

fs/jbd2/journal.c

1965

for (block = log_offset; block < journal->j_total_len; block++) {

fs/jbd2/journal.c

1966

err = jbd2_journal_bmap(journal, block, &phys_block);

fs/jbd2/journal.c

197

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

198

timer_delete_sync(&journal->j_commit_timer);

fs/jbd2/journal.c

1989

if (block != journal->j_total_len - 1)

fs/jbd2/journal.c

199

jbd2_journal_commit_transaction(journal);

fs/jbd2/journal.c

1997

byte_start = block_start * journal->j_blocksize;

fs/jbd2/journal.c

1998

byte_stop = block_stop * journal->j_blocksize;

fs/jbd2/journal.c

1999

byte_count = (block_stop - block_start) * journal->j_blocksize;

fs/jbd2/journal.c

200

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

2001

truncate_inode_pages_range(journal->j_dev->bd_mapping,

fs/jbd2/journal.c

2005

err = blkdev_issue_discard(journal->j_dev,

fs/jbd2/journal.c

2010

err = blkdev_issue_zeroout(journal->j_dev,

fs/jbd2/journal.c

2026

return blkdev_issue_flush(journal->j_dev);

fs/jbd2/journal.c

2036

void jbd2_journal_update_sb_errno(journal_t *journal)

fs/jbd2/journal.c

2038

journal_superblock_t *sb = journal->j_superblock;

fs/jbd2/journal.c

204

wake_up(&journal->j_wait_done_commit);

fs/jbd2/journal.c

2041

lock_buffer(journal->j_sb_buffer);

fs/jbd2/journal.c

2042

errcode = journal->j_errno;

fs/jbd2/journal.c

2048

jbd2_write_superblock(journal, REQ_FUA);

fs/jbd2/journal.c

2060

int jbd2_journal_load(journal_t *journal)

fs/jbd2/journal.c

2066

err = jbd2_journal_recover(journal);

fs/jbd2/journal.c

2072

if (journal->j_failed_commit) {

fs/jbd2/journal.c

2074

"is corrupt.\n", journal->j_failed_commit,

fs/jbd2/journal.c

2075

journal->j_devname);

fs/jbd2/journal.c

2082

journal->j_flags &= ~JBD2_ABORT;

fs/jbd2/journal.c

2087

err = journal_reset(journal);

fs/jbd2/journal.c

2093

journal->j_flags |= JBD2_LOADED;

fs/jbd2/journal.c

2105

int jbd2_journal_destroy(journal_t *journal)

fs/jbd2/journal.c

2110

journal_kill_thread(journal);

fs/jbd2/journal.c

2113

if (journal->j_running_transaction)

fs/jbd2/journal.c

2114

jbd2_journal_commit_transaction(journal);

fs/jbd2/journal.c

2119

spin_lock(&journal->j_list_lock);

fs/jbd2/journal.c

212

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

2120

while (journal->j_checkpoint_transactions != NULL) {

fs/jbd2/journal.c

2121

spin_unlock(&journal->j_list_lock);

fs/jbd2/journal.c

2122

mutex_lock_io(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

2123

err = jbd2_log_do_checkpoint(journal);

fs/jbd2/journal.c

2124

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

2130

jbd2_journal_destroy_checkpoint(journal);

fs/jbd2/journal.c

2131

spin_lock(&journal->j_list_lock);

fs/jbd2/journal.c

2134

spin_lock(&journal->j_list_lock);

fs/jbd2/journal.c

2137

J_ASSERT(journal->j_running_transaction == NULL);

fs/jbd2/journal.c

2138

J_ASSERT(journal->j_committing_transaction == NULL);

fs/jbd2/journal.c

2139

J_ASSERT(journal->j_checkpoint_transactions == NULL);

fs/jbd2/journal.c

214

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

2140

spin_unlock(&journal->j_list_lock);

fs/jbd2/journal.c

2148

if (!is_journal_aborted(journal)) {

fs/jbd2/journal.c

2149

int ret = jbd2_check_fs_dev_write_error(journal);

fs/jbd2/journal.c

2151

jbd2_journal_abort(journal, ret);

fs/jbd2/journal.c

2154

if (journal->j_sb_buffer) {

fs/jbd2/journal.c

2155

if (!is_journal_aborted(journal)) {

fs/jbd2/journal.c

2156

mutex_lock_io(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

2158

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

2159

journal->j_tail_sequence =

fs/jbd2/journal.c

2160

++journal->j_transaction_sequence;

fs/jbd2/journal.c

2161

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

2163

jbd2_mark_journal_empty(journal, REQ_PREFLUSH | REQ_FUA);

fs/jbd2/journal.c

2164

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

2167

brelse(journal->j_sb_buffer);

fs/jbd2/journal.c

2170

if (journal->j_shrinker) {

fs/jbd2/journal.c

2171

percpu_counter_destroy(&journal->j_checkpoint_jh_count);

fs/jbd2/journal.c

2172

shrinker_free(journal->j_shrinker);

fs/jbd2/journal.c

2174

if (journal->j_proc_entry)

fs/jbd2/journal.c

2175

jbd2_stats_proc_exit(journal);

fs/jbd2/journal.c

2176

iput(journal->j_inode);

fs/jbd2/journal.c

2177

if (journal->j_revoke)

fs/jbd2/journal.c

2178

jbd2_journal_destroy_revoke(journal);

fs/jbd2/journal.c

2179

kfree(journal->j_fc_wbuf);

fs/jbd2/journal.c

2180

kfree(journal->j_wbuf);

fs/jbd2/journal.c

2181

lockdep_unregister_key(&journal->jbd2_trans_commit_key);

fs/jbd2/journal.c

2182

kfree(journal);

fs/jbd2/journal.c

2199

int jbd2_journal_check_used_features(journal_t *journal, unsigned long compat,

fs/jbd2/journal.c

2206

if (!jbd2_format_support_feature(journal))

fs/jbd2/journal.c

2209

sb = journal->j_superblock;

fs/jbd2/journal.c

222

prepare_to_wait(&journal->j_wait_commit, &wait,

fs/jbd2/journal.c

2230

int jbd2_journal_check_available_features(journal_t *journal, unsigned long compat,

fs/jbd2/journal.c

2236

if (!jbd2_format_support_feature(journal))

fs/jbd2/journal.c

224

transaction = journal->j_running_transaction;

fs/jbd2/journal.c

2248

jbd2_journal_initialize_fast_commit(journal_t *journal)

fs/jbd2/journal.c

2250

journal_superblock_t *sb = journal->j_superblock;

fs/jbd2/journal.c

2254

if (num_fc_blks > journal->j_last)

fs/jbd2/journal.c

2256

if (journal->j_last - num_fc_blks < JBD2_MIN_JOURNAL_BLOCKS)

fs/jbd2/journal.c

2260

WARN_ON(journal->j_fc_wbuf != NULL);

fs/jbd2/journal.c

2261

journal->j_fc_wbuf = kmalloc_objs(struct buffer_head *, num_fc_blks);

fs/jbd2/journal.c

2262

if (!journal->j_fc_wbuf)

fs/jbd2/journal.c

2265

journal->j_fc_wbufsize = num_fc_blks;

fs/jbd2/journal.c

2266

journal->j_fc_last = journal->j_last;

fs/jbd2/journal.c

2267

journal->j_last = journal->j_fc_last - num_fc_blks;

fs/jbd2/journal.c

2268

journal->j_fc_first = journal->j_last + 1;

fs/jbd2/journal.c

2269

journal->j_fc_off = 0;

fs/jbd2/journal.c

227

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

2270

journal->j_free = journal->j_last - journal->j_first;

fs/jbd2/journal.c

2287

int jbd2_journal_set_features(journal_t *journal, unsigned long compat,

fs/jbd2/journal.c

229

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

2296

if (jbd2_journal_check_used_features(journal, compat, ro, incompat))

fs/jbd2/journal.c

2299

if (!jbd2_journal_check_available_features(journal, compat, ro, incompat))

fs/jbd2/journal.c

231

finish_wait(&journal->j_wait_commit, &wait);

fs/jbd2/journal.c

2316

sb = journal->j_superblock;

fs/jbd2/journal.c

2319

if (jbd2_journal_initialize_fast_commit(journal)) {

fs/jbd2/journal.c

2325

lock_buffer(journal->j_sb_buffer);

fs/jbd2/journal.c

2332

journal->j_csum_seed = jbd2_chksum(~0, sb->s_uuid,

fs/jbd2/journal.c

2349

if (jbd2_journal_has_csum_v2or3(journal))

fs/jbd2/journal.c

2351

unlock_buffer(journal->j_sb_buffer);

fs/jbd2/journal.c

2352

jbd2_journal_init_transaction_limits(journal);

fs/jbd2/journal.c

2370

void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,

fs/jbd2/journal.c

2378

sb = journal->j_superblock;

fs/jbd2/journal.c

2380

lock_buffer(journal->j_sb_buffer);

fs/jbd2/journal.c

2388

if (jbd2_journal_has_csum_v2or3(journal))

fs/jbd2/journal.c

239

transaction = journal->j_running_transaction;

fs/jbd2/journal.c

2390

unlock_buffer(journal->j_sb_buffer);

fs/jbd2/journal.c

2391

jbd2_journal_init_transaction_limits(journal);

fs/jbd2/journal.c

2409

int jbd2_journal_flush(journal_t *journal, unsigned int flags)

fs/jbd2/journal.c

241

journal->j_commit_request = transaction->t_tid;

fs/jbd2/journal.c

2414

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

2417

if (journal->j_running_transaction) {

fs/jbd2/journal.c

2418

transaction = journal->j_running_transaction;

fs/jbd2/journal.c

2419

__jbd2_log_start_commit(journal, transaction->t_tid);

fs/jbd2/journal.c

2420

} else if (journal->j_committing_transaction)

fs/jbd2/journal.c

2421

transaction = journal->j_committing_transaction;

fs/jbd2/journal.c

2427

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

2428

jbd2_log_wait_commit(journal, tid);

fs/jbd2/journal.c

2430

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

2434

spin_lock(&journal->j_list_lock);

fs/jbd2/journal.c

2435

while (!err && journal->j_checkpoint_transactions != NULL) {

fs/jbd2/journal.c

2436

spin_unlock(&journal->j_list_lock);

fs/jbd2/journal.c

2437

mutex_lock_io(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

2438

err = jbd2_log_do_checkpoint(journal);

fs/jbd2/journal.c

2439

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

2440

spin_lock(&journal->j_list_lock);

fs/jbd2/journal.c

2442

spin_unlock(&journal->j_list_lock);

fs/jbd2/journal.c

2444

if (is_journal_aborted(journal))

fs/jbd2/journal.c

2447

mutex_lock_io(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

2449

err = jbd2_cleanup_journal_tail(journal);

fs/jbd2/journal.c

2451

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

2462

jbd2_mark_journal_empty(journal, REQ_FUA);

fs/jbd2/journal.c

2465

err = __jbd2_journal_erase(journal, flags);

fs/jbd2/journal.c

2467

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

2468

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

2469

J_ASSERT(!journal->j_running_transaction);

fs/jbd2/journal.c

247

timer_delete_sync(&journal->j_commit_timer);

fs/jbd2/journal.c

2470

J_ASSERT(!journal->j_committing_transaction);

fs/jbd2/journal.c

2471

J_ASSERT(!journal->j_checkpoint_transactions);

fs/jbd2/journal.c

2472

J_ASSERT(journal->j_head == journal->j_tail);

fs/jbd2/journal.c

2473

J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);

fs/jbd2/journal.c

2474

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

248

journal->j_task = NULL;

fs/jbd2/journal.c

249

wake_up(&journal->j_wait_done_commit);

fs/jbd2/journal.c

2492

int jbd2_journal_wipe(journal_t *journal, int write)

fs/jbd2/journal.c

2496

J_ASSERT (!(journal->j_flags & JBD2_LOADED));

fs/jbd2/journal.c

2498

if (!journal->j_tail)

fs/jbd2/journal.c

2504

err = jbd2_journal_skip_recovery(journal);

fs/jbd2/journal.c

2507

mutex_lock_io(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

2508

jbd2_mark_journal_empty(journal, REQ_FUA);

fs/jbd2/journal.c

2509

mutex_unlock(&journal->j_checkpoint_mutex);

fs/jbd2/journal.c

251

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

255

static int jbd2_journal_start_thread(journal_t *journal)

fs/jbd2/journal.c

2556

void jbd2_journal_abort(journal_t *journal, int errno)

fs/jbd2/journal.c

2566

mutex_lock(&journal->j_abort_mutex);

fs/jbd2/journal.c

2572

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

2573

if (journal->j_flags & JBD2_ABORT) {

fs/jbd2/journal.c

2574

int old_errno = journal->j_errno;

fs/jbd2/journal.c

2576

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

2578

journal->j_errno = errno;

fs/jbd2/journal.c

2579

jbd2_journal_update_sb_errno(journal);

fs/jbd2/journal.c

2581

mutex_unlock(&journal->j_abort_mutex);

fs/jbd2/journal.c

2589

pr_err("Aborting journal on device %s.\n", journal->j_devname);

fs/jbd2/journal.c

259

t = kthread_run(kjournald2, journal, "jbd2/%s",

fs/jbd2/journal.c

2591

journal->j_flags |= JBD2_ABORT;

fs/jbd2/journal.c

2592

journal->j_errno = errno;

fs/jbd2/journal.c

2593

transaction = journal->j_running_transaction;

fs/jbd2/journal.c

2595

__jbd2_log_start_commit(journal, transaction->t_tid);

fs/jbd2/journal.c

2596

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

260

journal->j_devname);

fs/jbd2/journal.c

2602

jbd2_journal_update_sb_errno(journal);

fs/jbd2/journal.c

2603

mutex_unlock(&journal->j_abort_mutex);

fs/jbd2/journal.c

2617

int jbd2_journal_errno(journal_t *journal)

fs/jbd2/journal.c

2621

read_lock(&journal->j_state_lock);

fs/jbd2/journal.c

2622

if (journal->j_flags & JBD2_ABORT)

fs/jbd2/journal.c

2625

err = journal->j_errno;

fs/jbd2/journal.c

2626

read_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

2637

int jbd2_journal_clear_err(journal_t *journal)

fs/jbd2/journal.c

264

wait_event(journal->j_wait_done_commit, journal->j_task != NULL);

fs/jbd2/journal.c

2641

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

2642

if (journal->j_flags & JBD2_ABORT)

fs/jbd2/journal.c

2645

journal->j_errno = 0;

fs/jbd2/journal.c

2646

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

2657

void jbd2_journal_ack_err(journal_t *journal)

fs/jbd2/journal.c

2659

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

2660

if (journal->j_errno)

fs/jbd2/journal.c

2661

journal->j_flags |= JBD2_ACK_ERR;

fs/jbd2/journal.c

2662

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

2674

size_t journal_tag_bytes(journal_t *journal)

fs/jbd2/journal.c

2678

if (jbd2_has_feature_csum3(journal))

fs/jbd2/journal.c

268

static void journal_kill_thread(journal_t *journal)

fs/jbd2/journal.c

2683

if (jbd2_has_feature_csum2(journal))

fs/jbd2/journal.c

2686

if (jbd2_has_feature_64bit(journal))

fs/jbd2/journal.c

270

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

271

journal->j_flags |= JBD2_UNMOUNT;

fs/jbd2/journal.c

273

while (journal->j_task) {

fs/jbd2/journal.c

274

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

275

wake_up(&journal->j_wait_commit);

fs/jbd2/journal.c

276

wait_event(journal->j_wait_done_commit, journal->j_task == NULL);

fs/jbd2/journal.c

277

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

279

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

2919

void jbd2_journal_release_jbd_inode(journal_t *journal,

fs/jbd2/journal.c

2922

if (!journal)

fs/jbd2/journal.c

2925

spin_lock(&journal->j_list_lock);

fs/jbd2/journal.c

2932

spin_unlock(&journal->j_list_lock);

fs/jbd2/journal.c

2942

spin_unlock(&journal->j_list_lock);

fs/jbd2/journal.c

333

journal_t *journal = transaction->t_journal;

fs/jbd2/journal.c

411

new_bh->b_bdev = journal->j_dev;

fs/jbd2/journal.c

425

spin_lock(&journal->j_list_lock);

fs/jbd2/journal.c

427

spin_unlock(&journal->j_list_lock);

fs/jbd2/journal.c

443

static int __jbd2_log_start_commit(journal_t *journal, tid_t target)

fs/jbd2/journal.c

446

if (journal->j_commit_request == target)

fs/jbd2/journal.c

454

if (journal->j_running_transaction &&

fs/jbd2/journal.c

455

journal->j_running_transaction->t_tid == target) {

fs/jbd2/journal.c

461

journal->j_commit_request = target;

fs/jbd2/journal.c

463

journal->j_commit_request,

fs/jbd2/journal.c

464

journal->j_commit_sequence);

fs/jbd2/journal.c

465

journal->j_running_transaction->t_requested = jiffies;

fs/jbd2/journal.c

466

wake_up(&journal->j_wait_commit);

fs/jbd2/journal.c

468

} else if (!tid_geq(journal->j_commit_request, target))

fs/jbd2/journal.c

473

journal->j_commit_request,

fs/jbd2/journal.c

474

journal->j_commit_sequence,

fs/jbd2/journal.c

475

target, journal->j_running_transaction ?

fs/jbd2/journal.c

476

journal->j_running_transaction->t_tid : 0);

fs/jbd2/journal.c

480

int jbd2_log_start_commit(journal_t *journal, tid_t tid)

fs/jbd2/journal.c

484

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

485

ret = __jbd2_log_start_commit(journal, tid);

fs/jbd2/journal.c

486

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

497

static int __jbd2_journal_force_commit(journal_t *journal)

fs/jbd2/journal.c

503

read_lock(&journal->j_state_lock);

fs/jbd2/journal.c

504

if (journal->j_running_transaction && !current->journal_info) {

fs/jbd2/journal.c

505

transaction = journal->j_running_transaction;

fs/jbd2/journal.c

506

if (!tid_geq(journal->j_commit_request, transaction->t_tid))

fs/jbd2/journal.c

508

} else if (journal->j_committing_transaction)

fs/jbd2/journal.c

509

transaction = journal->j_committing_transaction;

fs/jbd2/journal.c

513

read_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

517

read_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

519

jbd2_log_start_commit(journal, tid);

fs/jbd2/journal.c

520

ret = jbd2_log_wait_commit(journal, tid);

fs/jbd2/journal.c

537

int jbd2_journal_force_commit_nested(journal_t *journal)

fs/jbd2/journal.c

541

ret = __jbd2_journal_force_commit(journal);

fs/jbd2/journal.c

552

int jbd2_journal_force_commit(journal_t *journal)

fs/jbd2/journal.c

557

ret = __jbd2_journal_force_commit(journal);

fs/jbd2/journal.c

568

int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)

fs/jbd2/journal.c

572

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

573

if (journal->j_running_transaction) {

fs/jbd2/journal.c

574

tid_t tid = journal->j_running_transaction->t_tid;

fs/jbd2/journal.c

576

__jbd2_log_start_commit(journal, tid);

fs/jbd2/journal.c

582

} else if (journal->j_committing_transaction) {

fs/jbd2/journal.c

588

*ptid = journal->j_committing_transaction->t_tid;

fs/jbd2/journal.c

591

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

601

int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid)

fs/jbd2/journal.c

606

if (!(journal->j_flags & JBD2_BARRIER))

fs/jbd2/journal.c

608

read_lock(&journal->j_state_lock);

fs/jbd2/journal.c

610

if (tid_geq(journal->j_commit_sequence, tid))

fs/jbd2/journal.c

612

commit_trans = journal->j_committing_transaction;

fs/jbd2/journal.c

614

running_trans = journal->j_running_transaction;

fs/jbd2/journal.c

631

if (journal->j_fs_dev != journal->j_dev) {

fs/jbd2/journal.c

641

read_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

650

int jbd2_log_wait_commit(journal_t *journal, tid_t tid)

fs/jbd2/journal.c

654

read_lock(&journal->j_state_lock);

fs/jbd2/journal.c

661

if (tid_gt(tid, journal->j_commit_sequence) &&

fs/jbd2/journal.c

662

(!journal->j_committing_transaction ||

fs/jbd2/journal.c

663

journal->j_committing_transaction->t_tid != tid)) {

fs/jbd2/journal.c

664

read_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

665

jbd2_might_wait_for_commit(journal);

fs/jbd2/journal.c

666

read_lock(&journal->j_state_lock);

fs/jbd2/journal.c

670

if (!tid_geq(journal->j_commit_request, tid)) {

fs/jbd2/journal.c

673

__func__, journal->j_commit_request, tid);

fs/jbd2/journal.c

676

while (tid_gt(tid, journal->j_commit_sequence)) {

fs/jbd2/journal.c

678

tid, journal->j_commit_sequence);

fs/jbd2/journal.c

679

read_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

680

wake_up(&journal->j_wait_commit);

fs/jbd2/journal.c

681

wait_event(journal->j_wait_done_commit,

fs/jbd2/journal.c

682

!tid_gt(tid, journal->j_commit_sequence));

fs/jbd2/journal.c

683

read_lock(&journal->j_state_lock);

fs/jbd2/journal.c

685

read_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

687

if (unlikely(is_journal_aborted(journal)))

fs/jbd2/journal.c

699

int jbd2_fc_begin_commit(journal_t *journal, tid_t tid)

fs/jbd2/journal.c

701

if (unlikely(is_journal_aborted(journal)))

fs/jbd2/journal.c

707

if (!journal->j_stats.ts_tid)

fs/jbd2/journal.c

710

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

711

if (tid_geq(journal->j_commit_sequence, tid)) {

fs/jbd2/journal.c

712

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

716

if (journal->j_flags & JBD2_FULL_COMMIT_ONGOING ||

fs/jbd2/journal.c

717

(journal->j_flags & JBD2_FAST_COMMIT_ONGOING)) {

fs/jbd2/journal.c

720

prepare_to_wait(&journal->j_fc_wait, &wait,

fs/jbd2/journal.c

722

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

724

finish_wait(&journal->j_fc_wait, &wait);

fs/jbd2/journal.c

727

journal->j_flags |= JBD2_FAST_COMMIT_ONGOING;

fs/jbd2/journal.c

728

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

738

static int __jbd2_fc_end_commit(journal_t *journal, tid_t tid, bool fallback)

fs/jbd2/journal.c

740

if (journal->j_fc_cleanup_callback)

fs/jbd2/journal.c

741

journal->j_fc_cleanup_callback(journal, 0, tid);

fs/jbd2/journal.c

742

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

743

journal->j_flags &= ~JBD2_FAST_COMMIT_ONGOING;

fs/jbd2/journal.c

745

journal->j_flags |= JBD2_FULL_COMMIT_ONGOING;

fs/jbd2/journal.c

746

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

747

wake_up(&journal->j_fc_wait);

fs/jbd2/journal.c

749

return jbd2_complete_transaction(journal, tid);

fs/jbd2/journal.c

753

int jbd2_fc_end_commit(journal_t *journal)

fs/jbd2/journal.c

755

return __jbd2_fc_end_commit(journal, 0, false);

fs/jbd2/journal.c

759

int jbd2_fc_end_commit_fallback(journal_t *journal)

fs/jbd2/journal.c

763

read_lock(&journal->j_state_lock);

fs/jbd2/journal.c

764

tid = journal->j_running_transaction ?

fs/jbd2/journal.c

765

journal->j_running_transaction->t_tid : 0;

fs/jbd2/journal.c

766

read_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

767

return __jbd2_fc_end_commit(journal, tid, true);

fs/jbd2/journal.c

772

int jbd2_transaction_committed(journal_t *journal, tid_t tid)

fs/jbd2/journal.c

774

return tid_geq(READ_ONCE(journal->j_commit_sequence), tid);

fs/jbd2/journal.c

785

int jbd2_complete_transaction(journal_t *journal, tid_t tid)

fs/jbd2/journal.c

789

read_lock(&journal->j_state_lock);

fs/jbd2/journal.c

790

if (journal->j_running_transaction &&

fs/jbd2/journal.c

791

journal->j_running_transaction->t_tid == tid) {

fs/jbd2/journal.c

792

if (journal->j_commit_request != tid) {

fs/jbd2/journal.c

794

read_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

795

jbd2_log_start_commit(journal, tid);

fs/jbd2/journal.c

798

} else if (!(journal->j_committing_transaction &&

fs/jbd2/journal.c

799

journal->j_committing_transaction->t_tid == tid))

fs/jbd2/journal.c

801

read_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

805

return jbd2_log_wait_commit(journal, tid);

fs/jbd2/journal.c

813

int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp)

fs/jbd2/journal.c

817

write_lock(&journal->j_state_lock);

fs/jbd2/journal.c

818

J_ASSERT(journal->j_free > 1);

fs/jbd2/journal.c

820

blocknr = journal->j_head;

fs/jbd2/journal.c

821

journal->j_head++;

fs/jbd2/journal.c

822

journal->j_free--;

fs/jbd2/journal.c

823

if (journal->j_head == journal->j_last)

fs/jbd2/journal.c

824

journal->j_head = journal->j_first;

fs/jbd2/journal.c

825

write_unlock(&journal->j_state_lock);

fs/jbd2/journal.c

826

return jbd2_journal_bmap(journal, blocknr, retp);

fs/jbd2/journal.c

830

int jbd2_fc_get_buf(journal_t *journal, struct buffer_head **bh_out)

fs/jbd2/journal.c

840

if (journal->j_fc_off + journal->j_fc_first >= journal->j_fc_last)

fs/jbd2/journal.c

843

fc_off = journal->j_fc_off;

fs/jbd2/journal.c

844

blocknr = journal->j_fc_first + fc_off;

fs/jbd2/journal.c

845

journal->j_fc_off++;

fs/jbd2/journal.c

846

ret = jbd2_journal_bmap(journal, blocknr, &pblock);

fs/jbd2/journal.c

850

bh = __getblk(journal->j_dev, pblock, journal->j_blocksize);

fs/jbd2/journal.c

854

journal->j_fc_wbuf[fc_off] = bh;

fs/jbd2/journal.c

866

int jbd2_fc_wait_bufs(journal_t *journal, int num_blks)

fs/jbd2/journal.c

871

j_fc_off = journal->j_fc_off;

fs/jbd2/journal.c

878

bh = journal->j_fc_wbuf[i];

fs/jbd2/journal.c

885

journal->j_fc_off = i + 1;

fs/jbd2/journal.c

889

journal->j_fc_wbuf[i] = NULL;

fs/jbd2/journal.c

896

void jbd2_fc_release_bufs(journal_t *journal)

fs/jbd2/journal.c

901

j_fc_off = journal->j_fc_off;

fs/jbd2/journal.c

904

bh = journal->j_fc_wbuf[i];

fs/jbd2/journal.c

908

journal->j_fc_wbuf[i] = NULL;

fs/jbd2/journal.c

920

int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,

fs/jbd2/journal.c

927

if (journal->j_bmap) {

fs/jbd2/journal.c

928

err = journal->j_bmap(journal, &block);

fs/jbd2/journal.c

931

} else if (journal->j_inode) {

fs/jbd2/journal.c

932

ret = bmap(journal->j_inode, &block);

fs/jbd2/journal.c

937

__func__, blocknr, journal->j_devname);

fs/jbd2/journal.c

938

jbd2_journal_abort(journal, ret ? ret : -EFSCORRUPTED);

fs/jbd2/journal.c

963

journal_t *journal = transaction->t_journal;

fs/jbd2/journal.c

969

err = jbd2_journal_next_log_block(journal, &blocknr);

fs/jbd2/journal.c

974

bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);

fs/jbd2/journal.c

979

memset(bh->b_data, 0, journal->j_blocksize);

fs/jbd2/recovery.c

125

static int jread(struct buffer_head **bhp, journal_t *journal,

fs/jbd2/recovery.c

134

if (offset >= journal->j_total_len) {

fs/jbd2/recovery.c

139

err = jbd2_journal_bmap(journal, offset, &blocknr);

fs/jbd2/recovery.c

147

bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);

fs/jbd2/recovery.c

160

do_readahead(journal, offset);

fs/jbd2/recovery.c

198

static int count_tags(journal_t *journal, struct buffer_head *bh)

fs/jbd2/recovery.c

202

int nr = 0, size = journal->j_blocksize;

fs/jbd2/recovery.c

203

int tag_bytes = journal_tag_bytes(journal);

fs/jbd2/recovery.c

205

if (jbd2_journal_has_csum_v2or3(journal))

fs/jbd2/recovery.c

227

#define wrap(journal, var) \

fs/jbd2/recovery.c

229

if (var >= (journal)->j_last) \

fs/jbd2/recovery.c

230

var -= ((journal)->j_last - (journal)->j_first); \

fs/jbd2/recovery.c

233

static int fc_do_one_pass(journal_t *journal,

fs/jbd2/recovery.c

241

next_fc_block = journal->j_fc_first;

fs/jbd2/recovery.c

242

if (!journal->j_fc_replay_callback)

fs/jbd2/recovery.c

245

while (next_fc_block <= journal->j_fc_last) {

fs/jbd2/recovery.c

248

err = jread(&bh, journal, next_fc_block);

fs/jbd2/recovery.c

254

err = journal->j_fc_replay_callback(journal, bh, pass,

fs/jbd2/recovery.c

255

next_fc_block - journal->j_fc_first,

fs/jbd2/recovery.c

282

int jbd2_journal_recover(journal_t *journal)

fs/jbd2/recovery.c

296

if (!journal->j_tail) {

fs/jbd2/recovery.c

297

journal_superblock_t *sb = journal->j_superblock;

fs/jbd2/recovery.c

301

journal->j_transaction_sequence = be32_to_cpu(sb->s_sequence) + 1;

fs/jbd2/recovery.c

302

journal->j_head = be32_to_cpu(sb->s_head);

fs/jbd2/recovery.c

306

err = do_one_pass(journal, &info, PASS_SCAN);

fs/jbd2/recovery.c

308

err = do_one_pass(journal, &info, PASS_REVOKE);

fs/jbd2/recovery.c

310

err = do_one_pass(journal, &info, PASS_REPLAY);

fs/jbd2/recovery.c

320

journal->j_transaction_sequence = ++info.end_transaction;

fs/jbd2/recovery.c

321

journal->j_head = info.head_block;

fs/jbd2/recovery.c

323

journal->j_transaction_sequence, journal->j_head);

fs/jbd2/recovery.c

325

jbd2_journal_clear_revoke(journal);

fs/jbd2/recovery.c

327

if (journal->j_revoke != journal->j_revoke_table[0] &&

fs/jbd2/recovery.c

328

journal->j_revoke != journal->j_revoke_table[1]) {

fs/jbd2/recovery.c

329

jbd2_journal_destroy_revoke_table(journal->j_revoke);

fs/jbd2/recovery.c

330

journal->j_revoke = journal->j_revoke_table[1];

fs/jbd2/recovery.c

332

err2 = sync_blockdev(journal->j_fs_dev);

fs/jbd2/recovery.c

335

err2 = jbd2_check_fs_dev_write_error(journal);

fs/jbd2/recovery.c

339

if (journal->j_flags & JBD2_BARRIER) {

fs/jbd2/recovery.c

340

err2 = blkdev_issue_flush(journal->j_fs_dev);

fs/jbd2/recovery.c

360

int jbd2_journal_skip_recovery(journal_t *journal)

fs/jbd2/recovery.c

368

err = do_one_pass(journal, &info, PASS_SCAN);

fs/jbd2/recovery.c

372

++journal->j_transaction_sequence;

fs/jbd2/recovery.c

373

journal->j_head = journal->j_first;

fs/jbd2/recovery.c

377

be32_to_cpu(journal->j_superblock->s_sequence);

fs/jbd2/recovery.c

382

journal->j_transaction_sequence = ++info.end_transaction;

fs/jbd2/recovery.c

383

journal->j_head = info.head_block;

fs/jbd2/recovery.c

386

journal->j_tail = 0;

fs/jbd2/recovery.c

390

static inline unsigned long long read_tag_block(journal_t *journal,

fs/jbd2/recovery.c

394

if (jbd2_has_feature_64bit(journal))

fs/jbd2/recovery.c

40

static int do_one_pass(journal_t *journal,

fs/jbd2/recovery.c

403

static int calc_chksums(journal_t *journal, struct buffer_head *bh,

fs/jbd2/recovery.c

410

num_blks = count_tags(journal, bh);

fs/jbd2/recovery.c

416

wrap(journal, *next_log_block);

fs/jbd2/recovery.c

417

err = jread(&obh, journal, io_block);

fs/jbd2/recovery.c

490

static __always_inline int jbd2_do_replay(journal_t *journal,

fs/jbd2/recovery.c

499

int tag_bytes = journal_tag_bytes(journal);

fs/jbd2/recovery.c

506

if (jbd2_journal_has_csum_v2or3(journal))

fs/jbd2/recovery.c

511

journal->j_blocksize - descr_csum_size) {

fs/jbd2/recovery.c

518

wrap(journal, *next_log_block);

fs/jbd2/recovery.c

519

err = jread(&obh, journal, io_block);

fs/jbd2/recovery.c

529

blocknr = read_tag_block(journal, &tag);

fs/jbd2/recovery.c

532

if (jbd2_journal_test_revoke(journal, blocknr,

fs/jbd2/recovery.c

540

if (!jbd2_block_tag_csum_verify(journal, &tag,

fs/jbd2/recovery.c

551

nbh = __getblk(journal->j_fs_dev, blocknr,

fs/jbd2/recovery.c

552

journal->j_blocksize);

fs/jbd2/recovery.c

560

memcpy(nbh->b_data, obh->b_data, journal->j_blocksize);

fs/jbd2/recovery.c

588

static int do_one_pass(journal_t *journal,

fs/jbd2/recovery.c

609

sb = journal->j_superblock;

fs/jbd2/recovery.c

632

journal->j_revoke =

fs/jbd2/recovery.c

634

if (!journal->j_revoke) {

fs/jbd2/recovery.c

638

journal->j_revoke = journal->j_revoke_table[1];

fs/jbd2/recovery.c

664

next_commit_ID, next_log_block, journal->j_last);

fs/jbd2/recovery.c

673

err = jread(&bh, journal, next_log_block);

fs/jbd2/recovery.c

678

wrap(journal, next_log_block);

fs/jbd2/recovery.c

68

static void do_readahead(journal_t *journal, unsigned int start)

fs/jbd2/recovery.c

706

if (!jbd2_descriptor_block_csum_verify(journal,

fs/jbd2/recovery.c

730

jbd2_has_feature_checksum(journal) &&

fs/jbd2/recovery.c

732

if (calc_chksums(journal, bh,

fs/jbd2/recovery.c

738

next_log_block += count_tags(journal, bh);

fs/jbd2/recovery.c

739

wrap(journal, next_log_block);

fs/jbd2/recovery.c

748

err = jbd2_do_replay(journal, info, bh, &next_log_block,

fs/jbd2/recovery.c

77

max = start + (128 * 1024 / journal->j_blocksize);

fs/jbd2/recovery.c

78

if (max > journal->j_total_len)

fs/jbd2/recovery.c

79

max = journal->j_total_len;

fs/jbd2/recovery.c

826

if (jbd2_has_feature_checksum(journal)) {

fs/jbd2/recovery.c

833

journal->j_failed_commit =

fs/jbd2/recovery.c

853

if (jbd2_commit_block_csum_verify(journal, bh->b_data))

fs/jbd2/recovery.c

856

if (jbd2_commit_block_csum_verify_partial(journal,

fs/jbd2/recovery.c

869

if (!jbd2_has_feature_async_commit(journal)) {

fs/jbd2/recovery.c

87

int err = jbd2_journal_bmap(journal, next, &blocknr);

fs/jbd2/recovery.c

870

journal->j_failed_commit = next_commit_ID;

fs/jbd2/recovery.c

893

!jbd2_descriptor_block_csum_verify(journal,

fs/jbd2/recovery.c

900

err = scan_revoke_records(journal, pass, bh,

fs/jbd2/recovery.c

939

if (jbd2_has_feature_fast_commit(journal) && pass != PASS_REVOKE) {

fs/jbd2/recovery.c

940

err = fc_do_one_pass(journal, info, pass);

fs/jbd2/recovery.c

95

bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);

fs/jbd2/recovery.c

954

static int scan_revoke_records(journal_t *journal, enum passtype pass,

fs/jbd2/recovery.c

968

if (jbd2_journal_has_csum_v2or3(journal))

fs/jbd2/recovery.c

970

if (rcount > journal->j_blocksize - csum_size)

fs/jbd2/recovery.c

974

if (jbd2_has_feature_64bit(journal))

fs/jbd2/recovery.c

991

err = jbd2_journal_set_revoke(journal, blocknr, sequence);

fs/jbd2/revoke.c

131

static inline int hash(journal_t *journal, unsigned long long block)

fs/jbd2/revoke.c

133

return hash_64(block, journal->j_revoke->hash_shift);

fs/jbd2/revoke.c

136

static int insert_revoke_hash(journal_t *journal, unsigned long long blocknr,

fs/jbd2/revoke.c

151

hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];

fs/jbd2/revoke.c

152

spin_lock(&journal->j_revoke_lock);

fs/jbd2/revoke.c

154

spin_unlock(&journal->j_revoke_lock);

fs/jbd2/revoke.c

160

static struct jbd2_revoke_record_s *find_revoke_record(journal_t *journal,

fs/jbd2/revoke.c

166

hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];

fs/jbd2/revoke.c

168

spin_lock(&journal->j_revoke_lock);

fs/jbd2/revoke.c

172

spin_unlock(&journal->j_revoke_lock);

fs/jbd2/revoke.c

177

spin_unlock(&journal->j_revoke_lock);

fs/jbd2/revoke.c

263

int jbd2_journal_init_revoke(journal_t *journal, int hash_size)

fs/jbd2/revoke.c

265

J_ASSERT(journal->j_revoke_table[0] == NULL);

fs/jbd2/revoke.c

268

journal->j_revoke_table[0] = jbd2_journal_init_revoke_table(hash_size);

fs/jbd2/revoke.c

269

if (!journal->j_revoke_table[0])

fs/jbd2/revoke.c

272

journal->j_revoke_table[1] = jbd2_journal_init_revoke_table(hash_size);

fs/jbd2/revoke.c

273

if (!journal->j_revoke_table[1])

fs/jbd2/revoke.c

276

journal->j_revoke = journal->j_revoke_table[1];

fs/jbd2/revoke.c

278

spin_lock_init(&journal->j_revoke_lock);

fs/jbd2/revoke.c

283

jbd2_journal_destroy_revoke_table(journal->j_revoke_table[0]);

fs/jbd2/revoke.c

284

journal->j_revoke_table[0] = NULL;

fs/jbd2/revoke.c

290

void jbd2_journal_destroy_revoke(journal_t *journal)

fs/jbd2/revoke.c

292

journal->j_revoke = NULL;

fs/jbd2/revoke.c

293

if (journal->j_revoke_table[0])

fs/jbd2/revoke.c

294

jbd2_journal_destroy_revoke_table(journal->j_revoke_table[0]);

fs/jbd2/revoke.c

295

if (journal->j_revoke_table[1])

fs/jbd2/revoke.c

296

jbd2_journal_destroy_revoke_table(journal->j_revoke_table[1]);

fs/jbd2/revoke.c

330

journal_t *journal;

fs/jbd2/revoke.c

338

journal = handle->h_transaction->t_journal;

fs/jbd2/revoke.c

339

if (!jbd2_journal_set_features(journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)){

fs/jbd2/revoke.c

344

bdev = journal->j_fs_dev;

fs/jbd2/revoke.c

349

journal->j_blocksize);

fs/jbd2/revoke.c

360

journal->j_blocksize);

fs/jbd2/revoke.c

404

err = insert_revoke_hash(journal, blocknr,

fs/jbd2/revoke.c

428

journal_t *journal = handle->h_transaction->t_journal;

fs/jbd2/revoke.c

447

record = find_revoke_record(journal, bh->b_blocknr);

fs/jbd2/revoke.c

451

spin_lock(&journal->j_revoke_lock);

fs/jbd2/revoke.c

453

spin_unlock(&journal->j_revoke_lock);

fs/jbd2/revoke.c

460

record = find_revoke_record(journal, bh->b_blocknr);

fs/jbd2/revoke.c

486

void jbd2_clear_buffer_revoked_flags(journal_t *journal)

fs/jbd2/revoke.c

488

struct jbd2_revoke_table_s *revoke = journal->j_revoke;

fs/jbd2/revoke.c

500

bh = __find_get_block_nonatomic(journal->j_fs_dev,

fs/jbd2/revoke.c

502

journal->j_blocksize);

fs/jbd2/revoke.c

515

void jbd2_journal_switch_revoke_table(journal_t *journal)

fs/jbd2/revoke.c

519

if (journal->j_revoke == journal->j_revoke_table[0])

fs/jbd2/revoke.c

520

journal->j_revoke = journal->j_revoke_table[1];

fs/jbd2/revoke.c

522

journal->j_revoke = journal->j_revoke_table[0];

fs/jbd2/revoke.c

524

for (i = 0; i < journal->j_revoke->hash_size; i++)

fs/jbd2/revoke.c

525

INIT_LIST_HEAD(&journal->j_revoke->hash_table[i]);

fs/jbd2/revoke.c

535

journal_t *journal = transaction->t_journal;

fs/jbd2/revoke.c

547

revoke = journal->j_revoke == journal->j_revoke_table[0] ?

fs/jbd2/revoke.c

548

journal->j_revoke_table[1] : journal->j_revoke_table[0];

fs/jbd2/revoke.c

564

flush_descriptor(journal, descriptor, offset);

fs/jbd2/revoke.c

579

journal_t *journal = transaction->t_journal;

fs/jbd2/revoke.c

588

if (is_journal_aborted(journal))

fs/jbd2/revoke.c

595

if (jbd2_journal_has_csum_v2or3(journal))

fs/jbd2/revoke.c

598

if (jbd2_has_feature_64bit(journal))

fs/jbd2/revoke.c

605

if (offset + sz > journal->j_blocksize - csum_size) {

fs/jbd2/revoke.c

606

flush_descriptor(journal, descriptor, offset);

fs/jbd2/revoke.c

625

if (jbd2_has_feature_64bit(journal))

fs/jbd2/revoke.c

643

static void flush_descriptor(journal_t *journal,

fs/jbd2/revoke.c

649

if (is_journal_aborted(journal))

fs/jbd2/revoke.c

654

jbd2_descriptor_block_csum_set(journal, descriptor);

fs/jbd2/revoke.c

685

int jbd2_journal_set_revoke(journal_t *journal,

fs/jbd2/revoke.c

691

record = find_revoke_record(journal, blocknr);

fs/jbd2/revoke.c

699

return insert_revoke_hash(journal, blocknr, sequence);

fs/jbd2/revoke.c

709

int jbd2_journal_test_revoke(journal_t *journal,

fs/jbd2/revoke.c

715

record = find_revoke_record(journal, blocknr);

fs/jbd2/revoke.c

728

void jbd2_journal_clear_revoke(journal_t *journal)

fs/jbd2/revoke.c

735

revoke = journal->j_revoke;

fs/jbd2/transaction.c

100

J_ASSERT(journal->j_running_transaction == NULL);

fs/jbd2/transaction.c

101

journal->j_running_transaction = transaction;

fs/jbd2/transaction.c

1044

jbd2_journal_abort(journal, error);

fs/jbd2/transaction.c

1054

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

1067

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

1082

jbd2_journal_abort(journal, error);

fs/jbd2/transaction.c

1091

journal->j_committing_transaction)) {

fs/jbd2/transaction.c

1093

journal->j_devname, jh->b_next_transaction,

fs/jbd2/transaction.c

1094

jh->b_transaction, journal->j_committing_transaction);

fs/jbd2/transaction.c

1097

jbd2_journal_abort(journal, error);

fs/jbd2/transaction.c

1236

journal_t *journal;

fs/jbd2/transaction.c

1242

journal = handle->h_transaction->t_journal;

fs/jbd2/transaction.c

1243

rc = jbd2_check_fs_dev_write_error(journal);

fs/jbd2/transaction.c

1252

jbd2_journal_abort(journal, rc);

fs/jbd2/transaction.c

1291

journal_t *journal;

fs/jbd2/transaction.c

1299

journal = transaction->t_journal;

fs/jbd2/transaction.c

1318

(jh->b_transaction == journal->j_committing_transaction &&

fs/jbd2/transaction.c

1322

jbd2_journal_abort(journal, err);

fs/jbd2/transaction.c

1329

jbd2_journal_abort(journal, err);

fs/jbd2/transaction.c

1347

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

1349

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

1350

} else if (jh->b_transaction == journal->j_committing_transaction) {

fs/jbd2/transaction.c

1355

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

1357

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

138

static void wait_transaction_locked(journal_t *journal)

fs/jbd2/transaction.c

139

__releases(journal->j_state_lock)

fs/jbd2/transaction.c

143

tid_t tid = journal->j_running_transaction->t_tid;

fs/jbd2/transaction.c

145

prepare_to_wait_exclusive(&journal->j_wait_transaction_locked, &wait,

fs/jbd2/transaction.c

147

need_to_start = !tid_geq(journal->j_commit_request, tid);

fs/jbd2/transaction.c

148

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

150

jbd2_log_start_commit(journal, tid);

fs/jbd2/transaction.c

151

jbd2_might_wait_for_commit(journal);

fs/jbd2/transaction.c

1520

journal_t *journal;

fs/jbd2/transaction.c

153

finish_wait(&journal->j_wait_transaction_locked, &wait);

fs/jbd2/transaction.c

1530

journal = transaction->t_journal;

fs/jbd2/transaction.c

1552

journal->j_devname, jh->b_transaction,

fs/jbd2/transaction.c

161

static void wait_transaction_switching(journal_t *journal)

fs/jbd2/transaction.c

1616

journal->j_running_transaction)) {

fs/jbd2/transaction.c

162

__releases(journal->j_state_lock)

fs/jbd2/transaction.c

1620

journal->j_devname,

fs/jbd2/transaction.c

1624

journal->j_running_transaction,

fs/jbd2/transaction.c

1625

journal->j_running_transaction ?

fs/jbd2/transaction.c

1626

journal->j_running_transaction->t_tid : 0);

fs/jbd2/transaction.c

1643

journal->j_committing_transaction)) ||

fs/jbd2/transaction.c

1650

journal->j_devname,

fs/jbd2/transaction.c

166

if (WARN_ON(!journal->j_running_transaction ||

fs/jbd2/transaction.c

167

journal->j_running_transaction->t_state != T_SWITCH)) {

fs/jbd2/transaction.c

1675

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

1677

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

168

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

1705

journal_t *journal;

fs/jbd2/transaction.c

171

prepare_to_wait_exclusive(&journal->j_wait_transaction_locked, &wait,

fs/jbd2/transaction.c

1715

journal = transaction->t_journal;

fs/jbd2/transaction.c

173

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

1778

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

1786

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

1788

if (WARN_ON_ONCE(jh->b_transaction != journal->j_committing_transaction)) {

fs/jbd2/transaction.c

1806

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

1808

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

181

finish_wait(&journal->j_wait_transaction_locked, &wait);

fs/jbd2/transaction.c

1829

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

1832

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

184

static void sub_reserved_credits(journal_t *journal, int blocks)

fs/jbd2/transaction.c

1841

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

1855

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

186

atomic_sub(blocks, &journal->j_reserved_credits);

fs/jbd2/transaction.c

1861

jbd2_journal_abort(journal, err);

fs/jbd2/transaction.c

187

wake_up(&journal->j_wait_reserved);

fs/jbd2/transaction.c

1891

journal_t *journal;

fs/jbd2/transaction.c

191

static int jbd2_max_user_trans_buffers(journal_t *journal)

fs/jbd2/transaction.c

1911

journal = transaction->t_journal;

fs/jbd2/transaction.c

1918

trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev,

fs/jbd2/transaction.c

193

return journal->j_max_transaction_buffers -

fs/jbd2/transaction.c

194

journal->j_transaction_overhead_buffers;

fs/jbd2/transaction.c

1955

if (handle->h_sync && journal->j_last_sync_writer != pid &&

fs/jbd2/transaction.c

1956

journal->j_max_batch_time) {

fs/jbd2/transaction.c

1959

journal->j_last_sync_writer = pid;

fs/jbd2/transaction.c

1961

read_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

1962

commit_time = journal->j_average_commit_time;

fs/jbd2/transaction.c

1963

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

1969

1000*journal->j_min_batch_time);

fs/jbd2/transaction.c

1971

1000*journal->j_max_batch_time);

fs/jbd2/transaction.c

1998

jbd2_log_start_commit(journal, tid);

fs/jbd2/transaction.c

2017

err = jbd2_log_wait_commit(journal, tid);

fs/jbd2/transaction.c

208

static int add_transaction_credits(journal_t *journal, int blocks,

fs/jbd2/transaction.c

210

__must_hold(&journal->j_state_lock)

fs/jbd2/transaction.c

212

transaction_t *t = journal->j_running_transaction;

fs/jbd2/transaction.c

2180

bool jbd2_journal_try_to_free_buffers(journal_t *journal, struct folio *folio)

fs/jbd2/transaction.c

2205

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

2209

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

222

wait_transaction_locked(journal);

fs/jbd2/transaction.c

223

__acquire(&journal->j_state_lock); /* fake out sparse */

fs/jbd2/transaction.c

2305

static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh,

fs/jbd2/transaction.c

2325

write_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

2327

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

233

if (needed > journal->j_max_transaction_buffers) {

fs/jbd2/transaction.c

2373

if (journal->j_running_transaction) {

fs/jbd2/transaction.c

2379

journal->j_running_transaction);

fs/jbd2/transaction.c

2386

if (journal->j_committing_transaction) {

fs/jbd2/transaction.c

2389

journal->j_committing_transaction);

fs/jbd2/transaction.c

2399

} else if (transaction == journal->j_committing_transaction) {

fs/jbd2/transaction.c

2407

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

2409

write_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

2424

if (journal->j_running_transaction && buffer_jbddirty(bh))

fs/jbd2/transaction.c

2425

jh->b_next_transaction = journal->j_running_transaction;

fs/jbd2/transaction.c

2427

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

2429

write_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

2439

J_ASSERT_JH(jh, transaction == journal->j_running_transaction);

fs/jbd2/transaction.c

245

if (atomic_read(&journal->j_reserved_credits) + total >

fs/jbd2/transaction.c

2454

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

2456

write_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

246

jbd2_max_user_trans_buffers(journal)) {

fs/jbd2/transaction.c

247

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

248

jbd2_might_wait_for_commit(journal);

fs/jbd2/transaction.c

2482

int jbd2_journal_invalidate_folio(journal_t *journal, struct folio *folio,

fs/jbd2/transaction.c

249

wait_event(journal->j_wait_reserved,

fs/jbd2/transaction.c

250

atomic_read(&journal->j_reserved_credits) + total <=

fs/jbd2/transaction.c

251

jbd2_max_user_trans_buffers(journal));

fs/jbd2/transaction.c

2515

ret = journal_unmap_buffer(journal, bh, partial_page);

fs/jbd2/transaction.c

252

__acquire(&journal->j_state_lock); /* fake out sparse */

fs/jbd2/transaction.c

256

wait_transaction_locked(journal);

fs/jbd2/transaction.c

257

__acquire(&journal->j_state_lock); /* fake out sparse */

fs/jbd2/transaction.c

2681

void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)

fs/jbd2/transaction.c

2686

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

2689

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

2701

journal_t *journal;

fs/jbd2/transaction.c

2708

journal = transaction->t_journal;

fs/jbd2/transaction.c

2716

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

272

if (jbd2_log_space_left(journal) < journal->j_max_transaction_buffers) {

fs/jbd2/transaction.c

274

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

2747

journal->j_committing_transaction)) {

fs/jbd2/transaction.c

2749

journal->j_devname, jinode->i_next_transaction,

fs/jbd2/transaction.c

275

jbd2_might_wait_for_commit(journal);

fs/jbd2/transaction.c

2751

journal->j_committing_transaction);

fs/jbd2/transaction.c

276

write_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

2768

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

277

if (jbd2_log_space_left(journal) <

fs/jbd2/transaction.c

2770

jbd2_journal_abort(journal, err);

fs/jbd2/transaction.c

278

journal->j_max_transaction_buffers)

fs/jbd2/transaction.c

279

__jbd2_log_wait_for_space(journal);

fs/jbd2/transaction.c

280

write_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

2809

int jbd2_journal_begin_ordered_truncate(journal_t *journal,

fs/jbd2/transaction.c

281

__acquire(&journal->j_state_lock); /* fake out sparse */

fs/jbd2/transaction.c

2822

read_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

2823

commit_trans = journal->j_committing_transaction;

fs/jbd2/transaction.c

2824

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

2825

spin_lock(&journal->j_list_lock);

fs/jbd2/transaction.c

2827

spin_unlock(&journal->j_list_lock);

fs/jbd2/transaction.c

2832

jbd2_journal_abort(journal, ret);

fs/jbd2/transaction.c

289

needed = atomic_add_return(rsv_blocks, &journal->j_reserved_credits);

fs/jbd2/transaction.c

291

if (needed > jbd2_max_user_trans_buffers(journal) / 2) {

fs/jbd2/transaction.c

292

sub_reserved_credits(journal, rsv_blocks);

fs/jbd2/transaction.c

294

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

295

jbd2_might_wait_for_commit(journal);

fs/jbd2/transaction.c

296

wait_event(journal->j_wait_reserved,

fs/jbd2/transaction.c

297

atomic_read(&journal->j_reserved_credits) + rsv_blocks

fs/jbd2/transaction.c

298

<= jbd2_max_user_trans_buffers(journal) / 2);

fs/jbd2/transaction.c

299

__acquire(&journal->j_state_lock); /* fake out sparse */

fs/jbd2/transaction.c

312

static int start_this_handle(journal_t *journal, handle_t *handle,

fs/jbd2/transaction.c

328

if (rsv_blocks > jbd2_max_user_trans_buffers(journal) / 2 ||

fs/jbd2/transaction.c

329

rsv_blocks + blocks > jbd2_max_user_trans_buffers(journal)) {

fs/jbd2/transaction.c

333

jbd2_max_user_trans_buffers(journal));

fs/jbd2/transaction.c

344

if (!data_race(journal->j_running_transaction)) {

fs/jbd2/transaction.c

364

read_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

365

BUG_ON(journal->j_flags & JBD2_UNMOUNT);

fs/jbd2/transaction.c

366

if (is_journal_aborted(journal) ||

fs/jbd2/transaction.c

367

(journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) {

fs/jbd2/transaction.c

368

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

378

if (!handle->h_reserved && journal->j_barrier_count) {

fs/jbd2/transaction.c

379

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

380

wait_event(journal->j_wait_transaction_locked,

fs/jbd2/transaction.c

381

journal->j_barrier_count == 0);

fs/jbd2/transaction.c

385

if (!journal->j_running_transaction) {

fs/jbd2/transaction.c

386

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

389

write_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

390

if (!journal->j_running_transaction &&

fs/jbd2/transaction.c

391

(handle->h_reserved || !journal->j_barrier_count)) {

fs/jbd2/transaction.c

392

jbd2_get_transaction(journal, new_transaction);

fs/jbd2/transaction.c

395

write_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

399

transaction = journal->j_running_transaction;

fs/jbd2/transaction.c

403

if (add_transaction_credits(journal, blocks, rsv_blocks)) {

fs/jbd2/transaction.c

408

__release(&journal->j_state_lock);

fs/jbd2/transaction.c

420

wait_transaction_switching(journal);

fs/jbd2/transaction.c

423

sub_reserved_credits(journal, blocks);

fs/jbd2/transaction.c

440

jbd2_log_space_left(journal));

fs/jbd2/transaction.c

441

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

444

rwsem_acquire_read(&journal->j_trans_commit_map, 0, 1, _THIS_IP_);

fs/jbd2/transaction.c

466

handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks,

fs/jbd2/transaction.c

473

if (!journal)

fs/jbd2/transaction.c

477

if (WARN_ON_ONCE(handle->h_transaction->t_journal != journal))

fs/jbd2/transaction.c

484

journal->j_revoke_records_per_block);

fs/jbd2/transaction.c

497

rsv_handle->h_journal = journal;

fs/jbd2/transaction.c

502

err = start_this_handle(journal, handle, gfp_mask);

fs/jbd2/transaction.c

511

trace_jbd2_handle_start(journal->j_fs_dev->bd_dev,

fs/jbd2/transaction.c

539

handle_t *jbd2_journal_start(journal_t *journal, int nblocks)

fs/jbd2/transaction.c

541

return jbd2__journal_start(journal, nblocks, 0, 0, GFP_NOFS, 0, 0);

fs/jbd2/transaction.c

547

journal_t *journal = handle->h_journal;

fs/jbd2/transaction.c

550

sub_reserved_credits(journal, handle->h_total_credits);

fs/jbd2/transaction.c

557

journal_t *journal = handle->h_journal;

fs/jbd2/transaction.c

560

read_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

561

__jbd2_journal_unreserve_handle(handle, journal->j_running_transaction);

fs/jbd2/transaction.c

562

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

584

journal_t *journal = handle->h_journal;

fs/jbd2/transaction.c

606

ret = start_this_handle(journal, handle, GFP_NOFS);

fs/jbd2/transaction.c

608

handle->h_journal = journal;

fs/jbd2/transaction.c

614

trace_jbd2_handle_start(journal->j_fs_dev->bd_dev,

fs/jbd2/transaction.c

645

journal_t *journal;

fs/jbd2/transaction.c

651

journal = transaction->t_journal;

fs/jbd2/transaction.c

655

read_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

666

journal->j_revoke_records_per_block) -

fs/jbd2/transaction.c

669

journal->j_revoke_records_per_block);

fs/jbd2/transaction.c

673

if (wanted > journal->j_max_transaction_buffers) {

fs/jbd2/transaction.c

680

trace_jbd2_handle_extend(journal->j_fs_dev->bd_dev,

fs/jbd2/transaction.c

694

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

701

journal_t *journal = transaction->t_journal;

fs/jbd2/transaction.c

716

int rr_per_blk = journal->j_revoke_records_per_block;

fs/jbd2/transaction.c

733

wake_up(&journal->j_wait_updates);

fs/jbd2/transaction.c

735

rwsem_release(&journal->j_trans_commit_map, _THIS_IP_);

fs/jbd2/transaction.c

764

journal_t *journal;

fs/jbd2/transaction.c

773

journal = transaction->t_journal;

fs/jbd2/transaction.c

788

read_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

789

need_to_start = !tid_geq(journal->j_commit_request, tid);

fs/jbd2/transaction.c

790

read_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

792

jbd2_log_start_commit(journal, tid);

fs/jbd2/transaction.c

795

journal->j_revoke_records_per_block);

fs/jbd2/transaction.c

797

ret = start_this_handle(journal, handle, gfp_mask);

fs/jbd2/transaction.c

798

trace_jbd2_handle_restart(journal->j_fs_dev->bd_dev,

fs/jbd2/transaction.c

80

static void jbd2_get_transaction(journal_t *journal,

fs/jbd2/transaction.c

817

void jbd2_journal_wait_updates(journal_t *journal)

fs/jbd2/transaction.c

83

transaction->t_journal = journal;

fs/jbd2/transaction.c

832

transaction_t *transaction = journal->j_running_transaction;

fs/jbd2/transaction.c

837

prepare_to_wait(&journal->j_wait_updates, &wait,

fs/jbd2/transaction.c

840

finish_wait(&journal->j_wait_updates, &wait);

fs/jbd2/transaction.c

843

write_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

845

finish_wait(&journal->j_wait_updates, &wait);

fs/jbd2/transaction.c

846

write_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

86

transaction->t_tid = journal->j_transaction_sequence++;

fs/jbd2/transaction.c

860

void jbd2_journal_lock_updates(journal_t *journal)

fs/jbd2/transaction.c

862

jbd2_might_wait_for_commit(journal);

fs/jbd2/transaction.c

864

write_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

865

++journal->j_barrier_count;

fs/jbd2/transaction.c

868

if (atomic_read(&journal->j_reserved_credits)) {

fs/jbd2/transaction.c

869

write_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

87

transaction->t_expires = jiffies + journal->j_commit_interval;

fs/jbd2/transaction.c

870

wait_event(journal->j_wait_reserved,

fs/jbd2/transaction.c

871

atomic_read(&journal->j_reserved_credits) == 0);

fs/jbd2/transaction.c

872

write_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

876

jbd2_journal_wait_updates(journal);

fs/jbd2/transaction.c

878

write_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

886

mutex_lock(&journal->j_barrier);

fs/jbd2/transaction.c

897

void jbd2_journal_unlock_updates (journal_t *journal)

fs/jbd2/transaction.c

899

J_ASSERT(journal->j_barrier_count != 0);

fs/jbd2/transaction.c

90

journal->j_transaction_overhead_buffers +

fs/jbd2/transaction.c

901

mutex_unlock(&journal->j_barrier);

fs/jbd2/transaction.c

902

write_lock(&journal->j_state_lock);

fs/jbd2/transaction.c

903

--journal->j_barrier_count;

fs/jbd2/transaction.c

904

write_unlock(&journal->j_state_lock);

fs/jbd2/transaction.c

905

wake_up_all(&journal->j_wait_transaction_locked);

fs/jbd2/transaction.c

91

atomic_read(&journal->j_reserved_credits));

fs/jbd2/transaction.c

953

journal_t *journal;

fs/jbd2/transaction.c

958

journal = transaction->t_journal;

fs/jbd2/transaction.c

97

journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires);

fs/jbd2/transaction.c

98

add_timer(&journal->j_commit_timer);

fs/ocfs2/alloc.c

6019

struct ocfs2_journal *journal = osb->journal;

fs/ocfs2/alloc.c

6046

jbd2_journal_lock_updates(journal->j_journal);

fs/ocfs2/alloc.c

6047

status = jbd2_journal_flush(journal->j_journal, 0);

fs/ocfs2/alloc.c

6048

jbd2_journal_unlock_updates(journal->j_journal);

fs/ocfs2/alloc.c

6158

if (jbd2_journal_start_commit(osb->journal->j_journal, &target)) {

fs/ocfs2/alloc.c

6159

jbd2_log_wait_commit(osb->journal->j_journal, target);

fs/ocfs2/file.c

172

journal_t *journal = osb->journal->j_journal;

fs/ocfs2/file.c

191

if (journal->j_flags & JBD2_BARRIER &&

fs/ocfs2/file.c

192

!jbd2_trans_will_send_data_barrier(journal, commit_tid))

fs/ocfs2/file.c

194

err = jbd2_complete_transaction(journal, commit_tid);

fs/ocfs2/file.c

2510

ret = jbd2_journal_force_commit(osb->journal->j_journal);

fs/ocfs2/inode.c

1320

if (!osb->journal)

fs/ocfs2/inode.c

1323

jbd2_journal_release_jbd_inode(osb->journal->j_journal,

fs/ocfs2/inode.c

160

journal_t *journal = osb->journal->j_journal;

fs/ocfs2/inode.c

207

if (journal) {

fs/ocfs2/inode.c

212

read_lock(&journal->j_state_lock);

fs/ocfs2/inode.c

213

if (journal->j_running_transaction)

fs/ocfs2/inode.c

214

transaction = journal->j_running_transaction;

fs/ocfs2/inode.c

216

transaction = journal->j_committing_transaction;

fs/ocfs2/inode.c

220

tid = journal->j_commit_sequence;

fs/ocfs2/inode.c

221

read_unlock(&journal->j_state_lock);

fs/ocfs2/ioctl.c

268

oij.ij_journal_size = i_size_read(osb->journal->j_inode);

fs/ocfs2/journal.c

1024

struct ocfs2_journal *journal = osb->journal;

fs/ocfs2/journal.c

1025

struct buffer_head *bh = journal->j_bh;

fs/ocfs2/journal.c

1043

status = ocfs2_write_block(osb, bh, INODE_CACHE(journal->j_inode));

fs/ocfs2/journal.c

1056

struct ocfs2_journal *journal = NULL;

fs/ocfs2/journal.c

1063

journal = osb->journal;

fs/ocfs2/journal.c

1064

if (!journal)

fs/ocfs2/journal.c

1067

inode = journal->j_inode;

fs/ocfs2/journal.c

1069

if (journal->j_state != OCFS2_JOURNAL_LOADED)

fs/ocfs2/journal.c

1076

num_running_trans = atomic_read(&(journal->j_num_trans));

fs/ocfs2/journal.c

1083

journal->j_state = OCFS2_JOURNAL_IN_SHUTDOWN;

fs/ocfs2/journal.c

1095

BUG_ON(atomic_read(&(journal->j_num_trans)) != 0);

fs/ocfs2/journal.c

1098

(journal->j_journal->j_flags & JBD2_LOADED)) {

fs/ocfs2/journal.c

1099

jbd2_journal_lock_updates(journal->j_journal);

fs/ocfs2/journal.c

1100

status = jbd2_journal_flush(journal->j_journal, 0);

fs/ocfs2/journal.c

1101

jbd2_journal_unlock_updates(journal->j_journal);

fs/ocfs2/journal.c

1107

if (!jbd2_journal_destroy(journal->j_journal) && !status) {

fs/ocfs2/journal.c

1116

journal->j_journal = NULL;

fs/ocfs2/journal.c

1123

brelse(journal->j_bh);

fs/ocfs2/journal.c

1124

journal->j_bh = NULL;

fs/ocfs2/journal.c

1126

journal->j_state = OCFS2_JOURNAL_FREE;

fs/ocfs2/journal.c

1130

kfree(journal);

fs/ocfs2/journal.c

1131

osb->journal = NULL;

fs/ocfs2/journal.c

1135

journal_t *journal,

fs/ocfs2/journal.c

1140

olderr = jbd2_journal_errno(journal);

fs/ocfs2/journal.c

1147

jbd2_journal_ack_err(journal);

fs/ocfs2/journal.c

1148

jbd2_journal_clear_err(journal);

fs/ocfs2/journal.c

1152

int ocfs2_journal_load(struct ocfs2_journal *journal, int local, int replayed)

fs/ocfs2/journal.c

1157

BUG_ON(!journal);

fs/ocfs2/journal.c

1159

osb = journal->j_osb;

fs/ocfs2/journal.c

1161

status = jbd2_journal_load(journal->j_journal);

fs/ocfs2/journal.c

1167

ocfs2_clear_journal_error(osb->sb, journal->j_journal, osb->slot_num);

fs/ocfs2/journal.c

1170

jbd2_journal_lock_updates(journal->j_journal);

fs/ocfs2/journal.c

1171

status = jbd2_journal_flush(journal->j_journal, 0);

fs/ocfs2/journal.c

1172

jbd2_journal_unlock_updates(journal->j_journal);

fs/ocfs2/journal.c

1204

int ocfs2_journal_wipe(struct ocfs2_journal *journal, int full)

fs/ocfs2/journal.c

1208

BUG_ON(!journal);

fs/ocfs2/journal.c

1210

status = jbd2_journal_wipe(journal->j_journal, full);

fs/ocfs2/journal.c

1216

status = ocfs2_journal_toggle_dirty(journal->j_osb, 0, 0);

fs/ocfs2/journal.c

1320

struct ocfs2_journal *journal =

fs/ocfs2/journal.c

1322

struct ocfs2_super *osb = journal->j_osb;

fs/ocfs2/journal.c

1330

(unsigned long long)OCFS2_I(journal->j_inode)->ip_blkno);

fs/ocfs2/journal.c

1332

spin_lock(&journal->j_lock);

fs/ocfs2/journal.c

1333

list_splice_init(&journal->j_la_cleanups, &tmp_la_list);

fs/ocfs2/journal.c

1334

spin_unlock(&journal->j_lock);

fs/ocfs2/journal.c

1391

static void ocfs2_queue_recovery_completion(struct ocfs2_journal *journal,

fs/ocfs2/journal.c

1422

spin_lock(&journal->j_lock);

fs/ocfs2/journal.c

1423

list_add_tail(&item->lri_list, &journal->j_la_cleanups);

fs/ocfs2/journal.c

1424

queue_work(journal->j_osb->ocfs2_wq, &journal->j_recovery_work);

fs/ocfs2/journal.c

1425

spin_unlock(&journal->j_lock);

fs/ocfs2/journal.c

1432

struct ocfs2_journal *journal = osb->journal;

fs/ocfs2/journal.c

1439

ocfs2_queue_recovery_completion(journal, osb->slot_num,

fs/ocfs2/journal.c

1455

ocfs2_queue_recovery_completion(osb->journal,

fs/ocfs2/journal.c

1516

ocfs2_queue_recovery_completion(osb->journal, osb->slot_num, NULL,

fs/ocfs2/journal.c

153

ocfs2_queue_recovery_completion(osb->journal, i, NULL,

fs/ocfs2/journal.c

1581

ocfs2_queue_recovery_completion(osb->journal,

fs/ocfs2/journal.c

1689

journal_t *journal = NULL;

fs/ocfs2/journal.c

1758

journal = jbd2_journal_init_inode(inode);

fs/ocfs2/journal.c

1759

if (IS_ERR(journal)) {

fs/ocfs2/journal.c

1761

status = PTR_ERR(journal);

fs/ocfs2/journal.c

1765

status = jbd2_journal_load(journal);

fs/ocfs2/journal.c

1769

jbd2_journal_destroy(journal);

fs/ocfs2/journal.c

1773

ocfs2_clear_journal_error(osb->sb, journal, slot_num);

fs/ocfs2/journal.c

1776

jbd2_journal_lock_updates(journal);

fs/ocfs2/journal.c

1777

status = jbd2_journal_flush(journal, 0);

fs/ocfs2/journal.c

1778

jbd2_journal_unlock_updates(journal);

fs/ocfs2/journal.c

1799

jbd2_journal_destroy(journal);

fs/ocfs2/journal.c

1872

ocfs2_queue_recovery_completion(osb->journal, slot_num, la_copy,

fs/ocfs2/journal.c

2061

ocfs2_queue_recovery_completion(osb->journal, i, NULL, NULL,

fs/ocfs2/journal.c

2403

struct ocfs2_journal *journal = osb->journal;

fs/ocfs2/journal.c

2410

atomic_read(&journal->j_num_trans) == 0)) {

fs/ocfs2/journal.c

2413

atomic_read(&journal->j_num_trans)

fs/ocfs2/journal.c

2432

if (kthread_should_stop() && atomic_read(&journal->j_num_trans)){

fs/ocfs2/journal.c

2436

atomic_read(&journal->j_num_trans));

fs/ocfs2/journal.c

313

struct ocfs2_journal *journal = NULL;

fs/ocfs2/journal.c

315

journal = osb->journal;

fs/ocfs2/journal.c

318

down_write(&journal->j_trans_barrier);

fs/ocfs2/journal.c

320

flushed = atomic_read(&journal->j_num_trans);

fs/ocfs2/journal.c

323

up_write(&journal->j_trans_barrier);

fs/ocfs2/journal.c

327

jbd2_journal_lock_updates(journal->j_journal);

fs/ocfs2/journal.c

328

status = jbd2_journal_flush(journal->j_journal, 0);

fs/ocfs2/journal.c

329

jbd2_journal_unlock_updates(journal->j_journal);

fs/ocfs2/journal.c

331

up_write(&journal->j_trans_barrier);

fs/ocfs2/journal.c

336

ocfs2_inc_trans_id(journal);

fs/ocfs2/journal.c

338

flushed = atomic_read(&journal->j_num_trans);

fs/ocfs2/journal.c

339

atomic_set(&journal->j_num_trans, 0);

fs/ocfs2/journal.c

340

up_write(&journal->j_trans_barrier);

fs/ocfs2/journal.c

342

trace_ocfs2_commit_cache_end(journal->j_trans_id, flushed);

fs/ocfs2/journal.c

345

wake_up(&journal->j_checkpointed);

fs/ocfs2/journal.c

352

journal_t *journal = osb->journal->j_journal;

fs/ocfs2/journal.c

355

BUG_ON(!osb || !osb->journal->j_journal);

fs/ocfs2/journal.c

360

BUG_ON(osb->journal->j_state == OCFS2_JOURNAL_FREE);

fs/ocfs2/journal.c

365

return jbd2_journal_start(journal, max_buffs);

fs/ocfs2/journal.c

369

down_read(&osb->journal->j_trans_barrier);

fs/ocfs2/journal.c

371

handle = jbd2_journal_start(journal, max_buffs);

fs/ocfs2/journal.c

373

up_read(&osb->journal->j_trans_barrier);

fs/ocfs2/journal.c

378

if (is_journal_aborted(journal)) {

fs/ocfs2/journal.c

384

atomic_inc(&(osb->journal->j_num_trans));

fs/ocfs2/journal.c

394

struct ocfs2_journal *journal = osb->journal;

fs/ocfs2/journal.c

404

up_read(&journal->j_trans_barrier);

fs/ocfs2/journal.c

62

static void ocfs2_queue_recovery_completion(struct ocfs2_journal *journal,

fs/ocfs2/journal.c

705

ocfs2_set_ci_lock_trans(osb->journal, ci);

fs/ocfs2/journal.c

839

journal_t *journal = handle->h_transaction->t_journal;

fs/ocfs2/journal.c

849

jbd2_journal_abort(journal, status);

fs/ocfs2/journal.c

858

journal_t *journal = osb->journal->j_journal;

fs/ocfs2/journal.c

864

write_lock(&journal->j_state_lock);

fs/ocfs2/journal.c

865

journal->j_commit_interval = commit_interval;

fs/ocfs2/journal.c

867

journal->j_flags |= JBD2_BARRIER;

fs/ocfs2/journal.c

869

journal->j_flags &= ~JBD2_BARRIER;

fs/ocfs2/journal.c

870

write_unlock(&journal->j_state_lock);

fs/ocfs2/journal.c

880

struct ocfs2_journal *journal;

fs/ocfs2/journal.c

882

journal = kzalloc_obj(struct ocfs2_journal);

fs/ocfs2/journal.c

883

if (!journal) {

fs/ocfs2/journal.c

888

osb->journal = journal;

fs/ocfs2/journal.c

889

journal->j_osb = osb;

fs/ocfs2/journal.c

891

atomic_set(&journal->j_num_trans, 0);

fs/ocfs2/journal.c

892

init_rwsem(&journal->j_trans_barrier);

fs/ocfs2/journal.c

893

init_waitqueue_head(&journal->j_checkpointed);

fs/ocfs2/journal.c

894

spin_lock_init(&journal->j_lock);

fs/ocfs2/journal.c

895

journal->j_trans_id = 1UL;

fs/ocfs2/journal.c

896

INIT_LIST_HEAD(&journal->j_la_cleanups);

fs/ocfs2/journal.c

897

INIT_WORK(&journal->j_recovery_work, ocfs2_complete_recovery);

fs/ocfs2/journal.c

898

journal->j_state = OCFS2_JOURNAL_FREE;

fs/ocfs2/journal.c

920

struct ocfs2_journal *journal = osb->journal;

fs/ocfs2/journal.c

925

BUG_ON(!journal);

fs/ocfs2/journal.c

982

journal->j_journal = j_journal;

fs/ocfs2/journal.c

983

journal->j_journal->j_submit_inode_data_buffers =

fs/ocfs2/journal.c

985

journal->j_journal->j_finish_inode_data_buffers =

fs/ocfs2/journal.c

987

journal->j_inode = inode;

fs/ocfs2/journal.c

988

journal->j_bh = bh;

fs/ocfs2/journal.c

992

journal->j_state = OCFS2_JOURNAL_LOADED;

fs/ocfs2/journal.h

110

struct ocfs2_journal *journal =

fs/ocfs2/journal.h

111

OCFS2_SB(ocfs2_metadata_cache_get_super(ci))->journal;

fs/ocfs2/journal.h

114

ret = !(time_after(journal->j_trans_id, ci->ci_created_trans));

fs/ocfs2/journal.h

137

ci->ci_created_trans = osb->journal->j_trans_id;

fs/ocfs2/journal.h

176

int ocfs2_journal_wipe(struct ocfs2_journal *journal,

fs/ocfs2/journal.h

178

int ocfs2_journal_load(struct ocfs2_journal *journal, int local,

fs/ocfs2/journal.h

199

if (!osb->journal)

fs/ocfs2/journal.h

211

wait_event(osb->journal->j_checkpointed,

fs/ocfs2/journal.h

595

OCFS2_SB(inode->i_sb)->journal->j_journal,

fs/ocfs2/journal.h

78

static inline void ocfs2_set_ci_lock_trans(struct ocfs2_journal *journal,

fs/ocfs2/journal.h

82

ci->ci_last_trans = journal->j_trans_id;

fs/ocfs2/journal.h

94

struct ocfs2_journal *journal =

fs/ocfs2/journal.h

95

OCFS2_SB(ocfs2_metadata_cache_get_super(ci))->journal;

fs/ocfs2/journal.h

98

ret = time_after(journal->j_trans_id, ci->ci_last_trans);

fs/ocfs2/namei.c

1576

if (!is_journal_aborted(osb->journal->j_journal)) {

fs/ocfs2/namei.c

1588

if (!is_journal_aborted(osb->journal->j_journal)) {

fs/ocfs2/ocfs2.h

390

struct ocfs2_journal *journal;

fs/ocfs2/super.c

1931

jbd2_journal_check_used_features(osb->journal->j_journal, 0, 0,

fs/ocfs2/super.c

2241

kfree(osb->journal);

fs/ocfs2/super.c

2358

status = ocfs2_journal_wipe(osb->journal, 0);

fs/ocfs2/super.c

2371

status = ocfs2_journal_load(osb->journal, local, dirty);

fs/ocfs2/super.c

2378

jbd2_journal_set_features(osb->journal->j_journal,

fs/ocfs2/super.c

2382

jbd2_journal_clear_features(osb->journal->j_journal,

fs/ocfs2/super.c

2456

kfree(osb->journal);

fs/ocfs2/super.c

289

"Journal", osb->journal->j_state,

fs/ocfs2/super.c

290

osb->journal->j_trans_id,

fs/ocfs2/super.c

291

atomic_read(&osb->journal->j_num_trans));

fs/ocfs2/super.c

413

if (jbd2_journal_start_commit(osb->journal->j_journal,

fs/ocfs2/super.c

416

jbd2_log_wait_commit(osb->journal->j_journal,

include/linux/jbd2.h

1290

void (*j_fc_cleanup_callback)(struct journal_s *journal, int full, tid_t tid);

include/linux/jbd2.h

1303

int (*j_fc_replay_callback)(struct journal_s *journal,

include/linux/jbd2.h

1314

int (*j_bmap)(struct journal_s *journal, sector_t *block);

include/linux/jbd2.h

1443

int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,

include/linux/jbd2.h

1445

int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);

include/linux/jbd2.h

1446

void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);

include/linux/jbd2.h

1454

void __jbd2_journal_clean_checkpoint_list(journal_t *journal, enum jbd2_shrink_type type);

include/linux/jbd2.h

1455

unsigned long jbd2_journal_shrink_checkpoint_list(journal_t *journal, unsigned long *nr_to_scan);

include/linux/jbd2.h

1458

void jbd2_journal_destroy_checkpoint(journal_t *journal);

include/linux/jbd2.h

1545

bool jbd2_journal_try_to_free_buffers(journal_t *journal, struct folio *folio);

include/linux/jbd2.h

1547

extern int jbd2_journal_flush(journal_t *journal, unsigned int flags);

include/linux/jbd2.h

1566

extern int jbd2_journal_load (journal_t *journal);

include/linux/jbd2.h

1568

extern int jbd2_journal_recover (journal_t *journal);

include/linux/jbd2.h

1589

extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,

include/linux/jbd2.h

1592

extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);

include/linux/jbd2.h

1658

extern void jbd2_journal_switch_revoke_table(journal_t *journal);

include/linux/jbd2.h

1659

extern void jbd2_clear_buffer_revoked_flags(journal_t *journal);

include/linux/jbd2.h

1668

int jbd2_log_start_commit(journal_t *journal, tid_t tid);

include/linux/jbd2.h

1669

int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);

include/linux/jbd2.h

1670

int jbd2_log_wait_commit(journal_t *journal, tid_t tid);

include/linux/jbd2.h

1671

int jbd2_transaction_committed(journal_t *journal, tid_t tid);

include/linux/jbd2.h

1672

int jbd2_complete_transaction(journal_t *journal, tid_t tid);

include/linux/jbd2.h

1673

int jbd2_log_do_checkpoint(journal_t *journal);

include/linux/jbd2.h

1674

int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid);

include/linux/jbd2.h

1676

void __jbd2_log_wait_for_space(journal_t *journal);

include/linux/jbd2.h

1681

int jbd2_fc_begin_commit(journal_t *journal, tid_t tid);

include/linux/jbd2.h

1682

int jbd2_fc_end_commit(journal_t *journal);

include/linux/jbd2.h

1683

int jbd2_fc_end_commit_fallback(journal_t *journal);

include/linux/jbd2.h

1684

int jbd2_fc_get_buf(journal_t *journal, struct buffer_head **bh_out);

include/linux/jbd2.h

1685

int jbd2_submit_inode_data(journal_t *journal, struct jbd2_inode *jinode);

include/linux/jbd2.h

1686

int jbd2_wait_inode_data(journal_t *journal, struct jbd2_inode *jinode);

include/linux/jbd2.h

1687

int jbd2_fc_wait_bufs(journal_t *journal, int num_blks);

include/linux/jbd2.h

1688

void jbd2_fc_release_bufs(journal_t *journal);

include/linux/jbd2.h

1700

static inline int is_journal_aborted(journal_t *journal)

include/linux/jbd2.h

1702

return journal->j_flags & JBD2_ABORT;

include/linux/jbd2.h

1717

static inline void jbd2_init_fs_dev_write_error(journal_t *journal)

include/linux/jbd2.h

1719

struct address_space *mapping = journal->j_fs_dev->bd_mapping;

include/linux/jbd2.h

1725

errseq_check_and_advance(&mapping->wb_err, &journal->j_fs_dev_wb_err);

include/linux/jbd2.h

1728

static inline int jbd2_check_fs_dev_write_error(journal_t *journal)

include/linux/jbd2.h

1730

struct address_space *mapping = journal->j_fs_dev->bd_mapping;

include/linux/jbd2.h

1733

READ_ONCE(journal->j_fs_dev_wb_err));

include/linux/jbd2.h

1754

extern size_t journal_tag_bytes(journal_t *journal);

include/linux/jbd2.h

1756

static inline int jbd2_journal_has_csum_v2or3(journal_t *journal)

include/linux/jbd2.h

1758

return jbd2_has_feature_csum2(journal) ||

include/linux/jbd2.h

1759

jbd2_has_feature_csum3(journal);

include/linux/jbd2.h

1772

static inline unsigned long jbd2_log_space_left(journal_t *journal)

include/linux/jbd2.h

1775

long free = journal->j_free - 32;

include/linux/jbd2.h

1777

if (journal->j_committing_transaction) {

include/linux/jbd2.h

1778

free -= atomic_read(&journal->

include/linux/jbd2.h

1802

static inline tid_t jbd2_get_latest_transaction(journal_t *journal)

include/linux/jbd2.h

1806

read_lock(&journal->j_state_lock);

include/linux/jbd2.h

1807

tid = journal->j_commit_request;

include/linux/jbd2.h

1808

if (journal->j_running_transaction)

include/linux/jbd2.h

1809

tid = journal->j_running_transaction->t_tid;

include/linux/jbd2.h

1810

read_unlock(&journal->j_state_lock);

include/linux/jbd2.h

1816

journal_t *journal;

include/linux/jbd2.h

1819

journal = handle->h_transaction->t_journal;

include/linux/jbd2.h

1821

journal = handle->h_journal;

include/linux/jbd2.h

1825

journal->j_revoke_records_per_block);

include/trace/events/ext4.h

3038

TP_PROTO(journal_t *journal, int full, tid_t tid),

include/trace/events/ext4.h

3040

TP_ARGS(journal, full, tid),

include/trace/events/ext4.h

3050

struct super_block *sb = journal->j_private;

include/trace/events/ext4.h

3053

__entry->j_fc_off = journal->j_fc_off;

include/trace/events/jbd2.h

105

__entry->dev = journal->j_fs_dev->bd_dev;

include/trace/events/jbd2.h

108

__entry->head = journal->j_tail_sequence;

include/trace/events/jbd2.h

16

TP_PROTO(journal_t *journal, int result),

include/trace/events/jbd2.h

18

TP_ARGS(journal, result),

include/trace/events/jbd2.h

26

__entry->dev = journal->j_fs_dev->bd_dev;

include/trace/events/jbd2.h

329

TP_PROTO(journal_t *journal, tid_t first_tid,

include/trace/events/jbd2.h

332

TP_ARGS(journal, first_tid, block_nr, freed),

include/trace/events/jbd2.h

343

__entry->dev = journal->j_fs_dev->bd_dev;

include/trace/events/jbd2.h

344

__entry->tail_sequence = journal->j_tail_sequence;

include/trace/events/jbd2.h

358

TP_PROTO(journal_t *journal, blk_opf_t write_flags),

include/trace/events/jbd2.h

36

TP_PROTO(journal_t *journal, transaction_t *commit_transaction),

include/trace/events/jbd2.h

360

TP_ARGS(journal, write_flags),

include/trace/events/jbd2.h

368

__entry->dev = journal->j_fs_dev->bd_dev;

include/trace/events/jbd2.h

38

TP_ARGS(journal, commit_transaction),

include/trace/events/jbd2.h

399

TP_PROTO(journal_t *journal, unsigned long nr_to_scan,

include/trace/events/jbd2.h

402

TP_ARGS(journal, nr_to_scan, count),

include/trace/events/jbd2.h

411

__entry->dev = journal->j_fs_dev->bd_dev;

include/trace/events/jbd2.h

423

TP_PROTO(journal_t *journal, unsigned long nr_to_scan, unsigned long count),

include/trace/events/jbd2.h

425

TP_ARGS(journal, nr_to_scan, count)

include/trace/events/jbd2.h

430

TP_PROTO(journal_t *journal, unsigned long nr_to_scan, unsigned long count),

include/trace/events/jbd2.h

432

TP_ARGS(journal, nr_to_scan, count)

include/trace/events/jbd2.h

437

TP_PROTO(journal_t *journal, unsigned long nr_to_scan,

include/trace/events/jbd2.h

440

TP_ARGS(journal, nr_to_scan, nr_shrunk, count),

include/trace/events/jbd2.h

450

__entry->dev = journal->j_fs_dev->bd_dev;

include/trace/events/jbd2.h

464

TP_PROTO(journal_t *journal, tid_t first_tid, tid_t tid, tid_t last_tid,

include/trace/events/jbd2.h

467

TP_ARGS(journal, first_tid, tid, last_tid, nr_freed, next_tid),

include/trace/events/jbd2.h

47

__entry->dev = journal->j_fs_dev->bd_dev;

include/trace/events/jbd2.h

479

__entry->dev = journal->j_fs_dev->bd_dev;

include/trace/events/jbd2.h

59

TP_PROTO(journal_t *journal, transaction_t *commit_transaction),

include/trace/events/jbd2.h

61

TP_ARGS(journal, commit_transaction)

include/trace/events/jbd2.h

66

TP_PROTO(journal_t *journal, transaction_t *commit_transaction),

include/trace/events/jbd2.h

68

TP_ARGS(journal, commit_transaction)

include/trace/events/jbd2.h

73

TP_PROTO(journal_t *journal, transaction_t *commit_transaction),

include/trace/events/jbd2.h

75

TP_ARGS(journal, commit_transaction)

include/trace/events/jbd2.h

80

TP_PROTO(journal_t *journal, transaction_t *commit_transaction),

include/trace/events/jbd2.h

82

TP_ARGS(journal, commit_transaction)

include/trace/events/jbd2.h

87

TP_PROTO(journal_t *journal, transaction_t *commit_transaction),

include/trace/events/jbd2.h

89

TP_ARGS(journal, commit_transaction)

include/trace/events/jbd2.h

93

TP_PROTO(journal_t *journal, transaction_t *commit_transaction),

include/trace/events/jbd2.h

95

TP_ARGS(journal, commit_transaction),