journal           458 drivers/md/bcache/bcache.h 	struct journal_device	journal;
journal           692 drivers/md/bcache/bcache.h 	struct journal		journal;
journal           343 drivers/md/bcache/btree.c 	if (w->journal) {
journal           344 drivers/md/bcache/btree.c 		atomic_dec_bug(w->journal);
journal           345 drivers/md/bcache/btree.c 		__closure_wake_up(&b->c->journal.wait);
journal           349 drivers/md/bcache/btree.c 	w->journal	= NULL;
journal           547 drivers/md/bcache/btree.c 		if (w->journal &&
journal           548 drivers/md/bcache/btree.c 		    journal_pin_cmp(b->c, w->journal, journal_ref)) {
journal           549 drivers/md/bcache/btree.c 			atomic_dec_bug(w->journal);
journal           550 drivers/md/bcache/btree.c 			w->journal = NULL;
journal           553 drivers/md/bcache/btree.c 		if (!w->journal) {
journal           554 drivers/md/bcache/btree.c 			w->journal = journal_ref;
journal           555 drivers/md/bcache/btree.c 			atomic_inc(w->journal);
journal           106 drivers/md/bcache/btree.h 	atomic_t		*journal;
journal            38 drivers/md/bcache/journal.c 	struct journal_device *ja = &ca->journal;
journal            42 drivers/md/bcache/journal.c 	struct jset *j, *data = ca->set->journal.w[0].data;
journal           187 drivers/md/bcache/journal.c 		struct journal_device *ja = &ca->journal;
journal           292 drivers/md/bcache/journal.c 		c->journal.seq = list_entry(list->prev,
journal           305 drivers/md/bcache/journal.c 	struct journal *j = &c->journal;
journal           430 drivers/md/bcache/journal.c 	if (c->journal.btree_flushing)
journal           433 drivers/md/bcache/journal.c 	spin_lock(&c->journal.flush_write_lock);
journal           434 drivers/md/bcache/journal.c 	if (c->journal.btree_flushing) {
journal           435 drivers/md/bcache/journal.c 		spin_unlock(&c->journal.flush_write_lock);
journal           438 drivers/md/bcache/journal.c 	c->journal.btree_flushing = true;
journal           439 drivers/md/bcache/journal.c 	spin_unlock(&c->journal.flush_write_lock);
journal           442 drivers/md/bcache/journal.c 	spin_lock(&c->journal.lock);
journal           443 drivers/md/bcache/journal.c 	fifo_front_p = &fifo_front(&c->journal.pin);
journal           450 drivers/md/bcache/journal.c 		spin_unlock(&c->journal.lock);
journal           453 drivers/md/bcache/journal.c 	spin_unlock(&c->journal.lock);
journal           455 drivers/md/bcache/journal.c 	mask = c->journal.pin.mask;
journal           468 drivers/md/bcache/journal.c 		now_fifo_front_p = &fifo_front(&c->journal.pin);
journal           495 drivers/md/bcache/journal.c 		if (!btree_current_write(b)->journal) {
journal           513 drivers/md/bcache/journal.c 		if (nr_to_fifo_front(btree_current_write(b)->journal,
journal           551 drivers/md/bcache/journal.c 		if (!btree_current_write(b)->journal) {
journal           571 drivers/md/bcache/journal.c 	spin_lock(&c->journal.flush_write_lock);
journal           572 drivers/md/bcache/journal.c 	c->journal.btree_flushing = false;
journal           573 drivers/md/bcache/journal.c 	spin_unlock(&c->journal.flush_write_lock);
journal           582 drivers/md/bcache/journal.c 	struct cache *ca = container_of(ja, struct cache, journal);
journal           586 drivers/md/bcache/journal.c 	closure_wake_up(&ca->set->journal.wait);
journal           600 drivers/md/bcache/journal.c 	struct journal_device *ja = &ca->journal;
journal           641 drivers/md/bcache/journal.c 	struct bkey *k = &c->journal.key;
journal           649 drivers/md/bcache/journal.c 	while (!atomic_read(&fifo_front(&c->journal.pin)))
journal           650 drivers/md/bcache/journal.c 		fifo_pop(&c->journal.pin, p);
journal           652 drivers/md/bcache/journal.c 	last_seq = last_seq(&c->journal);
journal           657 drivers/md/bcache/journal.c 		struct journal_device *ja = &ca->journal;
journal           668 drivers/md/bcache/journal.c 	if (c->journal.blocks_free)
journal           677 drivers/md/bcache/journal.c 		struct journal_device *ja = &ca->journal;
journal           694 drivers/md/bcache/journal.c 		c->journal.blocks_free = c->sb.bucket_size >> c->block_bits;
journal           697 drivers/md/bcache/journal.c 	if (!journal_full(&c->journal))
journal           698 drivers/md/bcache/journal.c 		__closure_wake_up(&c->journal.wait);
journal           701 drivers/md/bcache/journal.c void bch_journal_next(struct journal *j)
journal           730 drivers/md/bcache/journal.c 	closure_put(&w->c->journal.io);
journal           737 drivers/md/bcache/journal.c 	struct journal *j = container_of(cl, struct journal, io);
journal           747 drivers/md/bcache/journal.c 	__releases(&c->journal.lock)
journal           749 drivers/md/bcache/journal.c 	struct cache_set *c = container_of(cl, struct cache_set, journal.io);
journal           751 drivers/md/bcache/journal.c 	c->journal.io_in_flight = 0;
journal           752 drivers/md/bcache/journal.c 	spin_unlock(&c->journal.lock);
journal           756 drivers/md/bcache/journal.c 	__releases(c->journal.lock)
journal           758 drivers/md/bcache/journal.c 	struct cache_set *c = container_of(cl, struct cache_set, journal.io);
journal           760 drivers/md/bcache/journal.c 	struct journal_write *w = c->journal.cur;
journal           761 drivers/md/bcache/journal.c 	struct bkey *k = &c->journal.key;
journal           773 drivers/md/bcache/journal.c 	} else if (journal_full(&c->journal)) {
journal           775 drivers/md/bcache/journal.c 		spin_unlock(&c->journal.lock);
journal           782 drivers/md/bcache/journal.c 	c->journal.blocks_free -= set_blocks(w->data, block_bytes(c));
journal           794 drivers/md/bcache/journal.c 	w->data->last_seq	= last_seq(&c->journal);
journal           799 drivers/md/bcache/journal.c 		bio = &ca->journal.bio;
journal           819 drivers/md/bcache/journal.c 		ca->journal.seq[ca->journal.cur_idx] = w->data->seq;
journal           825 drivers/md/bcache/journal.c 	atomic_dec_bug(&fifo_back(&c->journal.pin));
journal           826 drivers/md/bcache/journal.c 	bch_journal_next(&c->journal);
journal           829 drivers/md/bcache/journal.c 	spin_unlock(&c->journal.lock);
journal           839 drivers/md/bcache/journal.c 	struct cache_set *c = container_of(cl, struct cache_set, journal.io);
journal           841 drivers/md/bcache/journal.c 	spin_lock(&c->journal.lock);
journal           846 drivers/md/bcache/journal.c 	__releases(c->journal.lock)
journal           848 drivers/md/bcache/journal.c 	struct closure *cl = &c->journal.io;
journal           849 drivers/md/bcache/journal.c 	struct journal_write *w = c->journal.cur;
journal           853 drivers/md/bcache/journal.c 	if (!c->journal.io_in_flight) {
journal           854 drivers/md/bcache/journal.c 		c->journal.io_in_flight = 1;
journal           857 drivers/md/bcache/journal.c 		spin_unlock(&c->journal.lock);
journal           863 drivers/md/bcache/journal.c 	__acquires(&c->journal.lock)
journal           871 drivers/md/bcache/journal.c 	spin_lock(&c->journal.lock);
journal           874 drivers/md/bcache/journal.c 		struct journal_write *w = c->journal.cur;
journal           880 drivers/md/bcache/journal.c 				     c->journal.blocks_free * c->sb.block_size,
journal           885 drivers/md/bcache/journal.c 			closure_wait(&c->journal.wait, &cl);
journal           887 drivers/md/bcache/journal.c 		if (!journal_full(&c->journal)) {
journal           905 drivers/md/bcache/journal.c 			spin_unlock(&c->journal.lock);
journal           911 drivers/md/bcache/journal.c 		spin_lock(&c->journal.lock);
journal           920 drivers/md/bcache/journal.c 					   journal.work);
journal           921 drivers/md/bcache/journal.c 	spin_lock(&c->journal.lock);
journal           922 drivers/md/bcache/journal.c 	if (c->journal.cur->dirty)
journal           925 drivers/md/bcache/journal.c 		spin_unlock(&c->journal.lock);
journal           953 drivers/md/bcache/journal.c 	ret = &fifo_back(&c->journal.pin);
journal           961 drivers/md/bcache/journal.c 		schedule_delayed_work(&c->journal.work,
journal           963 drivers/md/bcache/journal.c 		spin_unlock(&c->journal.lock);
journal           965 drivers/md/bcache/journal.c 		spin_unlock(&c->journal.lock);
journal           986 drivers/md/bcache/journal.c 	free_pages((unsigned long) c->journal.w[1].data, JSET_BITS);
journal           987 drivers/md/bcache/journal.c 	free_pages((unsigned long) c->journal.w[0].data, JSET_BITS);
journal           988 drivers/md/bcache/journal.c 	free_fifo(&c->journal.pin);
journal           993 drivers/md/bcache/journal.c 	struct journal *j = &c->journal;
journal           162 drivers/md/bcache/journal.h 	(fifo_idx(&(c)->journal.pin, (l)) > fifo_idx(&(c)->journal.pin, (r)))
journal           177 drivers/md/bcache/journal.h void bch_journal_next(struct journal *j);
journal          1645 drivers/md/bcache/super.c 	if (c->journal.cur) {
journal          1646 drivers/md/bcache/super.c 		cancel_delayed_work_sync(&c->journal.work);
journal          1648 drivers/md/bcache/super.c 		c->journal.work.work.func(&c->journal.work.work);
journal          1853 drivers/md/bcache/super.c 	LIST_HEAD(journal);
journal          1867 drivers/md/bcache/super.c 		if (bch_journal_read(c, &journal))
journal          1873 drivers/md/bcache/super.c 		if (list_empty(&journal))
journal          1876 drivers/md/bcache/super.c 		j = &list_entry(journal.prev, struct journal_replay, list)->j;
journal          1929 drivers/md/bcache/super.c 		bch_journal_mark(c, &journal);
journal          1938 drivers/md/bcache/super.c 		bch_journal_next(&c->journal);
journal          1959 drivers/md/bcache/super.c 		if (bch_journal_replay(c, &journal))
journal          2010 drivers/md/bcache/super.c 		bch_journal_next(&c->journal);
journal          2030 drivers/md/bcache/super.c 	while (!list_empty(&journal)) {
journal          2031 drivers/md/bcache/super.c 		l = list_first_entry(&journal, struct journal_replay, list);
journal          2160 drivers/md/bcache/super.c 	bio_init(&ca->journal.bio, ca->journal.bio.bi_inline_vecs, 8);
journal           764 drivers/md/bcache/sysfs.c 	sysfs_print(active_journal_entries,	fifo_used(&c->journal.pin));
journal           165 drivers/md/dm-integrity.c 	struct page_list *journal;
journal           672 drivers/md/dm-integrity.c 	return access_page_list(ic, ic->journal, section, offset, NULL);
journal           791 drivers/md/dm-integrity.c 		source_pl = ic->journal;
journal           795 drivers/md/dm-integrity.c 		target_pl = ic->journal;
journal           958 drivers/md/dm-integrity.c 		io_req.mem.ptr.pl = &ic->journal[pl_index];
journal          1076 drivers/md/dm-integrity.c 	io_req.mem.ptr.pl = &ic->journal[pl_index];
journal          2489 drivers/md/dm-integrity.c 			block_bitmap_op(ic, ic->journal, dio->range.logical_sector,
journal          2543 drivers/md/dm-integrity.c 	block_bitmap_op(ic, ic->journal, 0, limit, BITMAP_OP_CLEAR);
journal          2628 drivers/md/dm-integrity.c 		DEBUG_bytes(lowmem_page_address(ic->journal[0].page), 64, "decrypted journal");
journal          2835 drivers/md/dm-integrity.c 				block_bitmap_copy(ic, ic->recalc_bitmap, ic->journal);
journal          2836 drivers/md/dm-integrity.c 				block_bitmap_copy(ic, ic->may_write_bitmap, ic->journal);
journal          2837 drivers/md/dm-integrity.c 				if (!block_bitmap_op(ic, ic->journal, 0, ic->provided_data_sectors,
journal          2848 drivers/md/dm-integrity.c 				block_bitmap_op(ic, ic->journal, 0, ic->provided_data_sectors, BITMAP_OP_SET);
journal          2856 drivers/md/dm-integrity.c 			      block_bitmap_op(ic, ic->journal, 0, ic->provided_data_sectors, BITMAP_OP_TEST_ALL_CLEAR))) {
journal          2876 drivers/md/dm-integrity.c 			block_bitmap_op(ic, ic->journal, 0, ic->provided_data_sectors, BITMAP_OP_CLEAR);
journal          2881 drivers/md/dm-integrity.c 				block_bitmap_op(ic, ic->journal, le64_to_cpu(ic->sb->recalc_sector),
journal          3330 drivers/md/dm-integrity.c 	ic->journal = dm_integrity_alloc_page_list(ic->journal_pages);
journal          3331 drivers/md/dm-integrity.c 	if (!ic->journal) {
journal          3449 drivers/md/dm-integrity.c 			ic->journal_scatterlist = dm_integrity_alloc_journal_scatterlist(ic, ic->journal);
journal          4063 drivers/md/dm-integrity.c 			bbs->bitmap = lowmem_page_address(ic->journal[pl_index].page) + pl_offset;
journal          4145 drivers/md/dm-integrity.c 	dm_integrity_free_page_list(ic->journal);
journal          1797 fs/ext4/ext4.h EXT4_FEATURE_COMPAT_FUNCS(journal,		HAS_JOURNAL)
journal            44 fs/ext4/ext4_jbd2.c 	journal_t *journal;
journal            54 fs/ext4/ext4_jbd2.c 	journal = EXT4_SB(sb)->s_journal;
journal            60 fs/ext4/ext4_jbd2.c 	if (journal && is_journal_aborted(journal)) {
journal            70 fs/ext4/ext4_jbd2.c 	journal_t *journal;
journal            78 fs/ext4/ext4_jbd2.c 	journal = EXT4_SB(sb)->s_journal;
journal            79 fs/ext4/ext4_jbd2.c 	if (!journal)
journal            81 fs/ext4/ext4_jbd2.c 	return jbd2__journal_start(journal, blocks, rsv_blocks, GFP_NOFS,
journal           356 fs/ext4/ext4_jbd2.h static inline int ext4_journal_force_commit(journal_t *journal)
journal           358 fs/ext4/ext4_jbd2.h 	if (journal)
journal           359 fs/ext4/ext4_jbd2.h 		return jbd2_journal_force_commit(journal);
journal           256 fs/ext4/fsmap.c 	journal_t *journal = EXT4_SB(sb)->s_journal;
journal           279 fs/ext4/fsmap.c 	irec.fmr_physical = journal->j_blk_offset;
journal           280 fs/ext4/fsmap.c 	irec.fmr_length = journal->j_maxlen;
journal            99 fs/ext4/fsync.c 	journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
journal           119 fs/ext4/fsync.c 	if (!journal) {
journal           151 fs/ext4/fsync.c 	if (journal->j_flags & JBD2_BARRIER &&
journal           152 fs/ext4/fsync.c 	    !jbd2_trans_will_send_data_barrier(journal, commit_tid))
journal           154 fs/ext4/fsync.c 	ret = jbd2_complete_transaction(journal, commit_tid);
journal           232 fs/ext4/inode.c 			journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
journal           235 fs/ext4/inode.c 			jbd2_complete_transaction(journal, commit_tid);
journal          3272 fs/ext4/inode.c 	journal_t *journal;
journal          3312 fs/ext4/inode.c 		journal = EXT4_JOURNAL(inode);
journal          3313 fs/ext4/inode.c 		jbd2_journal_lock_updates(journal);
journal          3314 fs/ext4/inode.c 		err = jbd2_journal_flush(journal);
journal          3315 fs/ext4/inode.c 		jbd2_journal_unlock_updates(journal);
journal          3369 fs/ext4/inode.c 	journal_t *journal = EXT4_JOURNAL(page->mapping->host);
journal          3379 fs/ext4/inode.c 	return jbd2_journal_invalidatepage(journal, page, offset, length);
journal          3392 fs/ext4/inode.c 	journal_t *journal = EXT4_JOURNAL(page->mapping->host);
journal          3399 fs/ext4/inode.c 	if (journal)
journal          3400 fs/ext4/inode.c 		return jbd2_journal_try_to_free_buffers(journal, page, wait);
journal          3407 fs/ext4/inode.c 	journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
journal          3409 fs/ext4/inode.c 	if (journal)
journal          3410 fs/ext4/inode.c 		return !jbd2_transaction_committed(journal,
journal          4836 fs/ext4/inode.c 	journal_t *journal = EXT4_SB(sb)->s_journal;
journal          5009 fs/ext4/inode.c 	if (journal) {
journal          5013 fs/ext4/inode.c 		read_lock(&journal->j_state_lock);
journal          5014 fs/ext4/inode.c 		if (journal->j_running_transaction)
journal          5015 fs/ext4/inode.c 			transaction = journal->j_running_transaction;
journal          5017 fs/ext4/inode.c 			transaction = journal->j_committing_transaction;
journal          5021 fs/ext4/inode.c 			tid = journal->j_commit_sequence;
journal          5022 fs/ext4/inode.c 		read_unlock(&journal->j_state_lock);
journal          5480 fs/ext4/inode.c 	journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
journal          5508 fs/ext4/inode.c 		read_lock(&journal->j_state_lock);
journal          5509 fs/ext4/inode.c 		if (journal->j_committing_transaction)
journal          5510 fs/ext4/inode.c 			commit_tid = journal->j_committing_transaction->t_tid;
journal          5511 fs/ext4/inode.c 		read_unlock(&journal->j_state_lock);
journal          5513 fs/ext4/inode.c 			jbd2_log_wait_commit(journal, commit_tid);
journal          6147 fs/ext4/inode.c 	journal_t *journal;
journal          6162 fs/ext4/inode.c 	journal = EXT4_JOURNAL(inode);
journal          6163 fs/ext4/inode.c 	if (!journal)
journal          6165 fs/ext4/inode.c 	if (is_journal_aborted(journal))
journal          6189 fs/ext4/inode.c 	jbd2_journal_lock_updates(journal);
journal          6202 fs/ext4/inode.c 		err = jbd2_journal_flush(journal);
journal          6204 fs/ext4/inode.c 			jbd2_journal_unlock_updates(journal);
journal          6212 fs/ext4/inode.c 	jbd2_journal_unlock_updates(journal);
journal           412 fs/ext4/super.c static void ext4_journal_commit_callback(journal_t *journal, transaction_t *txn)
journal           414 fs/ext4/super.c 	struct super_block		*sb = journal->j_private;
journal           416 fs/ext4/super.c 	int				error = is_journal_aborted(journal);
journal           465 fs/ext4/super.c 		journal_t *journal = EXT4_SB(sb)->s_journal;
journal           468 fs/ext4/super.c 		if (journal)
journal           469 fs/ext4/super.c 			jbd2_journal_abort(journal, -EIO);
journal          1252 fs/ext4/super.c 	journal_t *journal = EXT4_SB(sb)->s_journal;
journal          1257 fs/ext4/super.c 	if (journal)
journal          1258 fs/ext4/super.c 		return jbd2_journal_try_to_free_buffers(journal, page,
journal          4754 fs/ext4/super.c static void ext4_init_journal_params(struct super_block *sb, journal_t *journal)
journal          4758 fs/ext4/super.c 	journal->j_commit_interval = sbi->s_commit_interval;
journal          4759 fs/ext4/super.c 	journal->j_min_batch_time = sbi->s_min_batch_time;
journal          4760 fs/ext4/super.c 	journal->j_max_batch_time = sbi->s_max_batch_time;
journal          4762 fs/ext4/super.c 	write_lock(&journal->j_state_lock);
journal          4764 fs/ext4/super.c 		journal->j_flags |= JBD2_BARRIER;
journal          4766 fs/ext4/super.c 		journal->j_flags &= ~JBD2_BARRIER;
journal          4768 fs/ext4/super.c 		journal->j_flags |= JBD2_ABORT_ON_SYNCDATA_ERR;
journal          4770 fs/ext4/super.c 		journal->j_flags &= ~JBD2_ABORT_ON_SYNCDATA_ERR;
journal          4771 fs/ext4/super.c 	write_unlock(&journal->j_state_lock);
journal          4810 fs/ext4/super.c 	journal_t *journal;
journal          4818 fs/ext4/super.c 	journal = jbd2_journal_init_inode(journal_inode);
journal          4819 fs/ext4/super.c 	if (!journal) {
journal          4824 fs/ext4/super.c 	journal->j_private = sb;
journal          4825 fs/ext4/super.c 	ext4_init_journal_params(sb, journal);
journal          4826 fs/ext4/super.c 	return journal;
journal          4833 fs/ext4/super.c 	journal_t *journal;
journal          4894 fs/ext4/super.c 	journal = jbd2_journal_init_dev(bdev, sb->s_bdev,
journal          4896 fs/ext4/super.c 	if (!journal) {
journal          4900 fs/ext4/super.c 	journal->j_private = sb;
journal          4901 fs/ext4/super.c 	ll_rw_block(REQ_OP_READ, REQ_META | REQ_PRIO, 1, &journal->j_sb_buffer);
journal          4902 fs/ext4/super.c 	wait_on_buffer(journal->j_sb_buffer);
journal          4903 fs/ext4/super.c 	if (!buffer_uptodate(journal->j_sb_buffer)) {
journal          4907 fs/ext4/super.c 	if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
journal          4910 fs/ext4/super.c 			be32_to_cpu(journal->j_superblock->s_nr_users));
journal          4914 fs/ext4/super.c 	ext4_init_journal_params(sb, journal);
journal          4915 fs/ext4/super.c 	return journal;
journal          4918 fs/ext4/super.c 	jbd2_journal_destroy(journal);
journal          4928 fs/ext4/super.c 	journal_t *journal;
journal          4973 fs/ext4/super.c 		if (!(journal = ext4_get_journal(sb, journal_inum)))
journal          4976 fs/ext4/super.c 		if (!(journal = ext4_get_dev_journal(sb, journal_dev)))
journal          4980 fs/ext4/super.c 	if (!(journal->j_flags & JBD2_BARRIER))
journal          4984 fs/ext4/super.c 		err = jbd2_journal_wipe(journal, !really_read_only);
journal          4990 fs/ext4/super.c 		err = jbd2_journal_load(journal);
journal          4999 fs/ext4/super.c 		jbd2_journal_destroy(journal);
journal          5003 fs/ext4/super.c 	EXT4_SB(sb)->s_journal = journal;
journal          5103 fs/ext4/super.c 	journal_t *journal = EXT4_SB(sb)->s_journal;
journal          5106 fs/ext4/super.c 		BUG_ON(journal != NULL);
journal          5109 fs/ext4/super.c 	jbd2_journal_lock_updates(journal);
journal          5110 fs/ext4/super.c 	if (jbd2_journal_flush(journal) < 0)
journal          5119 fs/ext4/super.c 	jbd2_journal_unlock_updates(journal);
journal          5130 fs/ext4/super.c 	journal_t *journal;
journal          5136 fs/ext4/super.c 	journal = EXT4_SB(sb)->s_journal;
journal          5143 fs/ext4/super.c 	j_errno = jbd2_journal_errno(journal);
journal          5156 fs/ext4/super.c 		jbd2_journal_clear_err(journal);
journal          5157 fs/ext4/super.c 		jbd2_journal_update_sb_errno(journal);
journal          5167 fs/ext4/super.c 	journal_t *journal;
journal          5172 fs/ext4/super.c 	journal = EXT4_SB(sb)->s_journal;
journal          5173 fs/ext4/super.c 	return ext4_journal_force_commit(journal);
journal          5232 fs/ext4/super.c 	journal_t *journal;
journal          5237 fs/ext4/super.c 	journal = EXT4_SB(sb)->s_journal;
journal          5239 fs/ext4/super.c 	if (journal) {
journal          5241 fs/ext4/super.c 		jbd2_journal_lock_updates(journal);
journal          5247 fs/ext4/super.c 		error = jbd2_journal_flush(journal);
journal          5257 fs/ext4/super.c 	if (journal)
journal          5259 fs/ext4/super.c 		jbd2_journal_unlock_updates(journal);
journal          1485 fs/f2fs/checkpoint.c 	seg_i->journal->info.kbytes_written = cpu_to_le64(kbytes_written);
journal           370 fs/f2fs/f2fs.h static inline int update_nats_in_cursum(struct f2fs_journal *journal, int i)
journal           372 fs/f2fs/f2fs.h 	int before = nats_in_cursum(journal);
journal           374 fs/f2fs/f2fs.h 	journal->n_nats = cpu_to_le16(before + i);
journal           378 fs/f2fs/f2fs.h static inline int update_sits_in_cursum(struct f2fs_journal *journal, int i)
journal           380 fs/f2fs/f2fs.h 	int before = sits_in_cursum(journal);
journal           382 fs/f2fs/f2fs.h 	journal->n_sits = cpu_to_le16(before + i);
journal           386 fs/f2fs/f2fs.h static inline bool __has_cursum_space(struct f2fs_journal *journal,
journal           390 fs/f2fs/f2fs.h 		return size <= MAX_NAT_JENTRIES(journal);
journal           391 fs/f2fs/f2fs.h 	return size <= MAX_SIT_JENTRIES(journal);
journal          3145 fs/f2fs/f2fs.h int f2fs_lookup_journal_in_cursum(struct f2fs_journal *journal, int type,
journal           521 fs/f2fs/node.c 	struct f2fs_journal *journal = curseg->journal;
journal           548 fs/f2fs/node.c 	i = f2fs_lookup_journal_in_cursum(journal, NAT_JOURNAL, nid, 0);
journal           550 fs/f2fs/node.c 		ne = nat_in_journal(journal, i);
journal          2258 fs/f2fs/node.c 	struct f2fs_journal *journal = curseg->journal;
journal          2262 fs/f2fs/node.c 	for (i = 0; i < nats_in_cursum(journal); i++) {
journal          2266 fs/f2fs/node.c 		addr = le32_to_cpu(nat_in_journal(journal, i).block_addr);
journal          2267 fs/f2fs/node.c 		nid = le32_to_cpu(nid_in_journal(journal, i));
journal          2704 fs/f2fs/node.c 	struct f2fs_journal *journal = curseg->journal;
journal          2708 fs/f2fs/node.c 	for (i = 0; i < nats_in_cursum(journal); i++) {
journal          2711 fs/f2fs/node.c 		nid_t nid = le32_to_cpu(nid_in_journal(journal, i));
journal          2713 fs/f2fs/node.c 		raw_ne = nat_in_journal(journal, i);
journal          2735 fs/f2fs/node.c 	update_nats_in_cursum(journal, -i);
journal          2794 fs/f2fs/node.c 	struct f2fs_journal *journal = curseg->journal;
journal          2807 fs/f2fs/node.c 		!__has_cursum_space(journal, set->entry_cnt, NAT_JOURNAL))
journal          2830 fs/f2fs/node.c 			offset = f2fs_lookup_journal_in_cursum(journal,
journal          2833 fs/f2fs/node.c 			raw_ne = &nat_in_journal(journal, offset);
journal          2834 fs/f2fs/node.c 			nid_in_journal(journal, offset) = cpu_to_le32(nid);
journal          2872 fs/f2fs/node.c 	struct f2fs_journal *journal = curseg->journal;
journal          2898 fs/f2fs/node.c 		!__has_cursum_space(journal, nm_i->dirty_nat_cnt, NAT_JOURNAL))
journal          2907 fs/f2fs/node.c 						MAX_NAT_JENTRIES(journal));
journal          2346 fs/f2fs/segment.c 	memcpy(&dst->journal, curseg->journal, SUM_JOURNAL_SIZE);
journal          3446 fs/f2fs/segment.c 	memcpy(seg_i->journal, kaddr, SUM_JOURNAL_SIZE);
journal          3450 fs/f2fs/segment.c 	memcpy(seg_i->journal, kaddr + SUM_JOURNAL_SIZE, SUM_JOURNAL_SIZE);
journal          3550 fs/f2fs/segment.c 	memcpy(curseg->journal, &sum->journal, SUM_JOURNAL_SIZE);
journal          3567 fs/f2fs/segment.c 	struct f2fs_journal *sit_j = CURSEG_I(sbi, CURSEG_COLD_DATA)->journal;
journal          3568 fs/f2fs/segment.c 	struct f2fs_journal *nat_j = CURSEG_I(sbi, CURSEG_HOT_DATA)->journal;
journal          3622 fs/f2fs/segment.c 	memcpy(kaddr, seg_i->journal, SUM_JOURNAL_SIZE);
journal          3627 fs/f2fs/segment.c 	memcpy(kaddr + written_size, seg_i->journal, SUM_JOURNAL_SIZE);
journal          3691 fs/f2fs/segment.c int f2fs_lookup_journal_in_cursum(struct f2fs_journal *journal, int type,
journal          3697 fs/f2fs/segment.c 		for (i = 0; i < nats_in_cursum(journal); i++) {
journal          3698 fs/f2fs/segment.c 			if (le32_to_cpu(nid_in_journal(journal, i)) == val)
journal          3701 fs/f2fs/segment.c 		if (alloc && __has_cursum_space(journal, 1, NAT_JOURNAL))
journal          3702 fs/f2fs/segment.c 			return update_nats_in_cursum(journal, 1);
journal          3704 fs/f2fs/segment.c 		for (i = 0; i < sits_in_cursum(journal); i++)
journal          3705 fs/f2fs/segment.c 			if (le32_to_cpu(segno_in_journal(journal, i)) == val)
journal          3707 fs/f2fs/segment.c 		if (alloc && __has_cursum_space(journal, 1, SIT_JOURNAL))
journal          3708 fs/f2fs/segment.c 			return update_sits_in_cursum(journal, 1);
journal          3803 fs/f2fs/segment.c 	struct f2fs_journal *journal = curseg->journal;
journal          3807 fs/f2fs/segment.c 	for (i = 0; i < sits_in_cursum(journal); i++) {
journal          3811 fs/f2fs/segment.c 		segno = le32_to_cpu(segno_in_journal(journal, i));
journal          3817 fs/f2fs/segment.c 	update_sits_in_cursum(journal, -i);
journal          3830 fs/f2fs/segment.c 	struct f2fs_journal *journal = curseg->journal;
journal          3852 fs/f2fs/segment.c 	if (!__has_cursum_space(journal, sit_i->dirty_sentries, SIT_JOURNAL) ||
journal          3870 fs/f2fs/segment.c 			!__has_cursum_space(journal, ses->entry_cnt, SIT_JOURNAL))
journal          3898 fs/f2fs/segment.c 				offset = f2fs_lookup_journal_in_cursum(journal,
journal          3901 fs/f2fs/segment.c 				segno_in_journal(journal, offset) =
journal          3904 fs/f2fs/segment.c 					&sit_in_journal(journal, offset));
journal          3906 fs/f2fs/segment.c 					&sit_in_journal(journal, offset));
journal          4103 fs/f2fs/segment.c 		array[i].journal = f2fs_kzalloc(sbi,
journal          4105 fs/f2fs/segment.c 		if (!array[i].journal)
journal          4117 fs/f2fs/segment.c 	struct f2fs_journal *journal = curseg->journal;
journal          4173 fs/f2fs/segment.c 	for (i = 0; i < sits_in_cursum(journal); i++) {
journal          4176 fs/f2fs/segment.c 		start = le32_to_cpu(segno_in_journal(journal, i));
journal          4185 fs/f2fs/segment.c 		sit = sit_in_journal(journal, i);
journal          4490 fs/f2fs/segment.c 		kvfree(array[i].journal);
journal           297 fs/f2fs/segment.h 	struct f2fs_journal *journal;		/* cached journal info */
journal          3437 fs/f2fs/super.c 			le64_to_cpu(seg_i->journal->info.kbytes_written);
journal           108 fs/jbd2/checkpoint.c void __jbd2_log_wait_for_space(journal_t *journal)
journal           113 fs/jbd2/checkpoint.c 	nblocks = jbd2_space_needed(journal);
journal           114 fs/jbd2/checkpoint.c 	while (jbd2_log_space_left(journal) < nblocks) {
journal           115 fs/jbd2/checkpoint.c 		write_unlock(&journal->j_state_lock);
journal           116 fs/jbd2/checkpoint.c 		mutex_lock_io(&journal->j_checkpoint_mutex);
journal           129 fs/jbd2/checkpoint.c 		write_lock(&journal->j_state_lock);
journal           130 fs/jbd2/checkpoint.c 		if (journal->j_flags & JBD2_ABORT) {
journal           131 fs/jbd2/checkpoint.c 			mutex_unlock(&journal->j_checkpoint_mutex);
journal           134 fs/jbd2/checkpoint.c 		spin_lock(&journal->j_list_lock);
journal           135 fs/jbd2/checkpoint.c 		space_left = jbd2_log_space_left(journal);
journal           137 fs/jbd2/checkpoint.c 			int chkpt = journal->j_checkpoint_transactions != NULL;
journal           140 fs/jbd2/checkpoint.c 			if (journal->j_committing_transaction)
journal           141 fs/jbd2/checkpoint.c 				tid = journal->j_committing_transaction->t_tid;
journal           142 fs/jbd2/checkpoint.c 			spin_unlock(&journal->j_list_lock);
journal           143 fs/jbd2/checkpoint.c 			write_unlock(&journal->j_state_lock);
journal           145 fs/jbd2/checkpoint.c 				jbd2_log_do_checkpoint(journal);
journal           146 fs/jbd2/checkpoint.c 			} else if (jbd2_cleanup_journal_tail(journal) == 0) {
journal           155 fs/jbd2/checkpoint.c 				mutex_unlock(&journal->j_checkpoint_mutex);
journal           156 fs/jbd2/checkpoint.c 				jbd2_log_wait_commit(journal, tid);
journal           157 fs/jbd2/checkpoint.c 				write_lock(&journal->j_state_lock);
journal           165 fs/jbd2/checkpoint.c 				       journal->j_devname);
journal           167 fs/jbd2/checkpoint.c 				jbd2_journal_abort(journal, -EIO);
journal           169 fs/jbd2/checkpoint.c 			write_lock(&journal->j_state_lock);
journal           171 fs/jbd2/checkpoint.c 			spin_unlock(&journal->j_list_lock);
journal           173 fs/jbd2/checkpoint.c 		mutex_unlock(&journal->j_checkpoint_mutex);
journal           178 fs/jbd2/checkpoint.c __flush_batch(journal_t *journal, int *batch_count)
journal           185 fs/jbd2/checkpoint.c 		write_dirty_buffer(journal->j_chkpt_bhs[i], REQ_SYNC);
journal           189 fs/jbd2/checkpoint.c 		struct buffer_head *bh = journal->j_chkpt_bhs[i];
journal           204 fs/jbd2/checkpoint.c int jbd2_log_do_checkpoint(journal_t *journal)
journal           219 fs/jbd2/checkpoint.c 	result = jbd2_cleanup_journal_tail(journal);
journal           220 fs/jbd2/checkpoint.c 	trace_jbd2_checkpoint(journal, result);
journal           230 fs/jbd2/checkpoint.c 	spin_lock(&journal->j_list_lock);
journal           231 fs/jbd2/checkpoint.c 	if (!journal->j_checkpoint_transactions)
journal           233 fs/jbd2/checkpoint.c 	transaction = journal->j_checkpoint_transactions;
journal           243 fs/jbd2/checkpoint.c 	if (journal->j_checkpoint_transactions != transaction ||
journal           254 fs/jbd2/checkpoint.c 			spin_unlock(&journal->j_list_lock);
journal           266 fs/jbd2/checkpoint.c 			spin_unlock(&journal->j_list_lock);
journal           267 fs/jbd2/checkpoint.c 			if (unlikely(journal->j_flags & JBD2_UNMOUNT))
journal           276 fs/jbd2/checkpoint.c 		journal->j_devname, (unsigned long long) bh->b_blocknr);
journal           279 fs/jbd2/checkpoint.c 				__flush_batch(journal, &batch_count);
journal           280 fs/jbd2/checkpoint.c 			jbd2_log_start_commit(journal, tid);
journal           289 fs/jbd2/checkpoint.c 			mutex_unlock(&journal->j_checkpoint_mutex);
journal           290 fs/jbd2/checkpoint.c 			jbd2_log_wait_commit(journal, tid);
journal           291 fs/jbd2/checkpoint.c 			mutex_lock_io(&journal->j_checkpoint_mutex);
journal           292 fs/jbd2/checkpoint.c 			spin_lock(&journal->j_list_lock);
journal           315 fs/jbd2/checkpoint.c 		journal->j_chkpt_bhs[batch_count++] = bh;
journal           320 fs/jbd2/checkpoint.c 		    spin_needbreak(&journal->j_list_lock))
journal           326 fs/jbd2/checkpoint.c 			spin_unlock(&journal->j_list_lock);
journal           329 fs/jbd2/checkpoint.c 				__flush_batch(journal, &batch_count);
journal           330 fs/jbd2/checkpoint.c 			spin_lock(&journal->j_list_lock);
journal           340 fs/jbd2/checkpoint.c 	if (journal->j_checkpoint_transactions != transaction ||
journal           349 fs/jbd2/checkpoint.c 			spin_unlock(&journal->j_list_lock);
journal           354 fs/jbd2/checkpoint.c 			spin_lock(&journal->j_list_lock);
journal           369 fs/jbd2/checkpoint.c 	spin_unlock(&journal->j_list_lock);
journal           371 fs/jbd2/checkpoint.c 		jbd2_journal_abort(journal, result);
journal           373 fs/jbd2/checkpoint.c 		result = jbd2_cleanup_journal_tail(journal);
journal           396 fs/jbd2/checkpoint.c int jbd2_cleanup_journal_tail(journal_t *journal)
journal           401 fs/jbd2/checkpoint.c 	if (is_journal_aborted(journal))
journal           404 fs/jbd2/checkpoint.c 	if (!jbd2_journal_get_log_tail(journal, &first_tid, &blocknr))
journal           416 fs/jbd2/checkpoint.c 	if (journal->j_flags & JBD2_BARRIER)
journal           417 fs/jbd2/checkpoint.c 		blkdev_issue_flush(journal->j_fs_dev, GFP_NOFS, NULL);
journal           419 fs/jbd2/checkpoint.c 	return __jbd2_update_log_tail(journal, first_tid, blocknr);
journal           476 fs/jbd2/checkpoint.c void __jbd2_journal_clean_checkpoint_list(journal_t *journal, bool destroy)
journal           481 fs/jbd2/checkpoint.c 	transaction = journal->j_checkpoint_transactions;
journal           524 fs/jbd2/checkpoint.c void jbd2_journal_destroy_checkpoint(journal_t *journal)
journal           531 fs/jbd2/checkpoint.c 		spin_lock(&journal->j_list_lock);
journal           532 fs/jbd2/checkpoint.c 		if (!journal->j_checkpoint_transactions) {
journal           533 fs/jbd2/checkpoint.c 			spin_unlock(&journal->j_list_lock);
journal           536 fs/jbd2/checkpoint.c 		__jbd2_journal_clean_checkpoint_list(journal, true);
journal           537 fs/jbd2/checkpoint.c 		spin_unlock(&journal->j_list_lock);
journal           564 fs/jbd2/checkpoint.c 	journal_t *journal;
journal           573 fs/jbd2/checkpoint.c 	journal = transaction->t_journal;
journal           602 fs/jbd2/checkpoint.c 	trace_jbd2_checkpoint_stats(journal->j_fs_dev->bd_dev,
journal           605 fs/jbd2/checkpoint.c 	__jbd2_journal_drop_transaction(journal, transaction);
journal           652 fs/jbd2/checkpoint.c void __jbd2_journal_drop_transaction(journal_t *journal, transaction_t *transaction)
journal           654 fs/jbd2/checkpoint.c 	assert_spin_locked(&journal->j_list_lock);
journal           658 fs/jbd2/checkpoint.c 		if (journal->j_checkpoint_transactions == transaction)
journal           659 fs/jbd2/checkpoint.c 			journal->j_checkpoint_transactions =
journal           661 fs/jbd2/checkpoint.c 		if (journal->j_checkpoint_transactions == transaction)
journal           662 fs/jbd2/checkpoint.c 			journal->j_checkpoint_transactions = NULL;
journal           672 fs/jbd2/checkpoint.c 	J_ASSERT(journal->j_committing_transaction != transaction);
journal           673 fs/jbd2/checkpoint.c 	J_ASSERT(journal->j_running_transaction != transaction);
journal           675 fs/jbd2/checkpoint.c 	trace_jbd2_drop_transaction(journal, transaction);
journal           116 fs/jbd2/commit.c static int journal_submit_commit_record(journal_t *journal,
journal           128 fs/jbd2/commit.c 	if (is_journal_aborted(journal))
journal           141 fs/jbd2/commit.c 	if (jbd2_has_feature_checksum(journal)) {
journal           146 fs/jbd2/commit.c 	jbd2_commit_block_csum_set(journal, bh);
journal           154 fs/jbd2/commit.c 	if (journal->j_flags & JBD2_BARRIER &&
journal           155 fs/jbd2/commit.c 	    !jbd2_has_feature_async_commit(journal))
journal           169 fs/jbd2/commit.c static int journal_wait_on_commit_record(journal_t *journal,
journal           213 fs/jbd2/commit.c static int journal_submit_data_buffers(journal_t *journal,
journal           220 fs/jbd2/commit.c 	spin_lock(&journal->j_list_lock);
journal           229 fs/jbd2/commit.c 		spin_unlock(&journal->j_list_lock);
journal           241 fs/jbd2/commit.c 		spin_lock(&journal->j_list_lock);
journal           247 fs/jbd2/commit.c 	spin_unlock(&journal->j_list_lock);
journal           256 fs/jbd2/commit.c static int journal_finish_inode_data_buffers(journal_t *journal,
journal           263 fs/jbd2/commit.c 	spin_lock(&journal->j_list_lock);
journal           271 fs/jbd2/commit.c 		spin_unlock(&journal->j_list_lock);
journal           277 fs/jbd2/commit.c 		spin_lock(&journal->j_list_lock);
journal           298 fs/jbd2/commit.c 	spin_unlock(&journal->j_list_lock);
journal           355 fs/jbd2/commit.c void jbd2_journal_commit_transaction(journal_t *journal)
journal           361 fs/jbd2/commit.c 	struct buffer_head **wbuf = journal->j_wbuf;
journal           374 fs/jbd2/commit.c 	int tag_bytes = journal_tag_bytes(journal);
journal           386 fs/jbd2/commit.c 	if (jbd2_journal_has_csum_v2or3(journal))
journal           395 fs/jbd2/commit.c 	if (journal->j_flags & JBD2_FLUSHED) {
journal           397 fs/jbd2/commit.c 		mutex_lock_io(&journal->j_checkpoint_mutex);
journal           404 fs/jbd2/commit.c 		jbd2_journal_update_sb_log_tail(journal,
journal           405 fs/jbd2/commit.c 						journal->j_tail_sequence,
journal           406 fs/jbd2/commit.c 						journal->j_tail,
journal           408 fs/jbd2/commit.c 		mutex_unlock(&journal->j_checkpoint_mutex);
journal           413 fs/jbd2/commit.c 	J_ASSERT(journal->j_running_transaction != NULL);
journal           414 fs/jbd2/commit.c 	J_ASSERT(journal->j_committing_transaction == NULL);
journal           416 fs/jbd2/commit.c 	commit_transaction = journal->j_running_transaction;
journal           418 fs/jbd2/commit.c 	trace_jbd2_start_commit(journal, commit_transaction);
journal           422 fs/jbd2/commit.c 	write_lock(&journal->j_state_lock);
journal           426 fs/jbd2/commit.c 	trace_jbd2_commit_locking(journal, commit_transaction);
journal           441 fs/jbd2/commit.c 		prepare_to_wait(&journal->j_wait_updates, &wait,
journal           445 fs/jbd2/commit.c 			write_unlock(&journal->j_state_lock);
journal           447 fs/jbd2/commit.c 			write_lock(&journal->j_state_lock);
journal           450 fs/jbd2/commit.c 		finish_wait(&journal->j_wait_updates, &wait);
journal           454 fs/jbd2/commit.c 	write_unlock(&journal->j_state_lock);
journal           457 fs/jbd2/commit.c 			journal->j_max_transaction_buffers);
journal           490 fs/jbd2/commit.c 		jbd2_journal_refile_buffer(journal, jh);
journal           498 fs/jbd2/commit.c 	spin_lock(&journal->j_list_lock);
journal           499 fs/jbd2/commit.c 	__jbd2_journal_clean_checkpoint_list(journal, false);
journal           500 fs/jbd2/commit.c 	spin_unlock(&journal->j_list_lock);
journal           508 fs/jbd2/commit.c 	jbd2_clear_buffer_revoked_flags(journal);
journal           513 fs/jbd2/commit.c 	jbd2_journal_switch_revoke_table(journal);
journal           518 fs/jbd2/commit.c 	atomic_sub(atomic_read(&journal->j_reserved_credits),
journal           521 fs/jbd2/commit.c 	write_lock(&journal->j_state_lock);
journal           522 fs/jbd2/commit.c 	trace_jbd2_commit_flushing(journal, commit_transaction);
journal           528 fs/jbd2/commit.c 	journal->j_committing_transaction = commit_transaction;
journal           529 fs/jbd2/commit.c 	journal->j_running_transaction = NULL;
journal           531 fs/jbd2/commit.c 	commit_transaction->t_log_start = journal->j_head;
journal           532 fs/jbd2/commit.c 	wake_up(&journal->j_wait_transaction_locked);
journal           533 fs/jbd2/commit.c 	write_unlock(&journal->j_state_lock);
journal           541 fs/jbd2/commit.c 	err = journal_submit_data_buffers(journal, commit_transaction);
journal           543 fs/jbd2/commit.c 		jbd2_journal_abort(journal, err);
journal           555 fs/jbd2/commit.c 	write_lock(&journal->j_state_lock);
journal           557 fs/jbd2/commit.c 	write_unlock(&journal->j_state_lock);
journal           559 fs/jbd2/commit.c 	trace_jbd2_commit_logging(journal, commit_transaction);
journal           582 fs/jbd2/commit.c 		if (is_journal_aborted(journal)) {
journal           589 fs/jbd2/commit.c 			jbd2_journal_refile_buffer(journal, jh);
journal           611 fs/jbd2/commit.c 				jbd2_journal_abort(journal, -EIO);
journal           634 fs/jbd2/commit.c 		err = jbd2_journal_next_log_block(journal, &blocknr);
journal           639 fs/jbd2/commit.c 			jbd2_journal_abort(journal, err);
journal           664 fs/jbd2/commit.c 			jbd2_journal_abort(journal, flags);
journal           679 fs/jbd2/commit.c 		write_tag_block(journal, tag, jh2bh(jh)->b_blocknr);
journal           681 fs/jbd2/commit.c 		jbd2_block_tag_csum_set(journal, tag, wbuf[bufs],
journal           688 fs/jbd2/commit.c 			memcpy (tagp, journal->j_uuid, 16);
journal           697 fs/jbd2/commit.c 		if (bufs == journal->j_wbufsize ||
journal           710 fs/jbd2/commit.c 				jbd2_descriptor_block_csum_set(journal,
journal           718 fs/jbd2/commit.c 				if (jbd2_has_feature_checksum(journal)) {
journal           738 fs/jbd2/commit.c 	err = journal_finish_inode_data_buffers(journal, commit_transaction);
journal           742 fs/jbd2/commit.c 		       "on %s\n", journal->j_devname);
journal           743 fs/jbd2/commit.c 		if (journal->j_flags & JBD2_ABORT_ON_SYNCDATA_ERR)
journal           744 fs/jbd2/commit.c 			jbd2_journal_abort(journal, err);
journal           756 fs/jbd2/commit.c 		jbd2_journal_get_log_tail(journal, &first_tid, &first_block);
journal           758 fs/jbd2/commit.c 	write_lock(&journal->j_state_lock);
journal           760 fs/jbd2/commit.c 		long freed = first_block - journal->j_tail;
journal           762 fs/jbd2/commit.c 		if (first_block < journal->j_tail)
journal           763 fs/jbd2/commit.c 			freed += journal->j_last - journal->j_first;
journal           765 fs/jbd2/commit.c 		if (freed < journal->j_maxlen / 4)
journal           770 fs/jbd2/commit.c 	write_unlock(&journal->j_state_lock);
journal           778 fs/jbd2/commit.c 	    (journal->j_fs_dev != journal->j_dev) &&
journal           779 fs/jbd2/commit.c 	    (journal->j_flags & JBD2_BARRIER))
journal           780 fs/jbd2/commit.c 		blkdev_issue_flush(journal->j_fs_dev, GFP_NOFS, NULL);
journal           783 fs/jbd2/commit.c 	if (jbd2_has_feature_async_commit(journal)) {
journal           784 fs/jbd2/commit.c 		err = journal_submit_commit_record(journal, commit_transaction,
journal           787 fs/jbd2/commit.c 			jbd2_journal_abort(journal, err);
journal           868 fs/jbd2/commit.c 		jbd2_journal_abort(journal, err);
journal           871 fs/jbd2/commit.c 	write_lock(&journal->j_state_lock);
journal           874 fs/jbd2/commit.c 	write_unlock(&journal->j_state_lock);
journal           876 fs/jbd2/commit.c 	if (!jbd2_has_feature_async_commit(journal)) {
journal           877 fs/jbd2/commit.c 		err = journal_submit_commit_record(journal, commit_transaction,
journal           880 fs/jbd2/commit.c 			jbd2_journal_abort(journal, err);
journal           883 fs/jbd2/commit.c 		err = journal_wait_on_commit_record(journal, cbh);
journal           885 fs/jbd2/commit.c 	if (jbd2_has_feature_async_commit(journal) &&
journal           886 fs/jbd2/commit.c 	    journal->j_flags & JBD2_BARRIER) {
journal           887 fs/jbd2/commit.c 		blkdev_issue_flush(journal->j_dev, GFP_NOFS, NULL);
journal           891 fs/jbd2/commit.c 		jbd2_journal_abort(journal, err);
journal           899 fs/jbd2/commit.c 		jbd2_update_log_tail(journal, first_tid, first_block);
journal           918 fs/jbd2/commit.c 	spin_lock(&journal->j_list_lock);
journal           925 fs/jbd2/commit.c 		spin_unlock(&journal->j_list_lock);
journal           962 fs/jbd2/commit.c 		spin_lock(&journal->j_list_lock);
journal          1015 fs/jbd2/commit.c 			if (is_journal_aborted(journal))
journal          1038 fs/jbd2/commit.c 		cond_resched_lock(&journal->j_list_lock);
journal          1040 fs/jbd2/commit.c 	spin_unlock(&journal->j_list_lock);
journal          1047 fs/jbd2/commit.c 	write_lock(&journal->j_state_lock);
journal          1048 fs/jbd2/commit.c 	spin_lock(&journal->j_list_lock);
journal          1054 fs/jbd2/commit.c 		spin_unlock(&journal->j_list_lock);
journal          1055 fs/jbd2/commit.c 		write_unlock(&journal->j_state_lock);
journal          1062 fs/jbd2/commit.c 	if (journal->j_checkpoint_transactions == NULL) {
journal          1063 fs/jbd2/commit.c 		journal->j_checkpoint_transactions = commit_transaction;
journal          1068 fs/jbd2/commit.c 			journal->j_checkpoint_transactions;
journal          1076 fs/jbd2/commit.c 	spin_unlock(&journal->j_list_lock);
journal          1094 fs/jbd2/commit.c 	trace_jbd2_run_stats(journal->j_fs_dev->bd_dev,
journal          1099 fs/jbd2/commit.c 	J_ASSERT(commit_transaction == journal->j_committing_transaction);
journal          1100 fs/jbd2/commit.c 	journal->j_commit_sequence = commit_transaction->t_tid;
journal          1101 fs/jbd2/commit.c 	journal->j_committing_transaction = NULL;
journal          1108 fs/jbd2/commit.c 	if (likely(journal->j_average_commit_time))
journal          1109 fs/jbd2/commit.c 		journal->j_average_commit_time = (commit_time +
journal          1110 fs/jbd2/commit.c 				journal->j_average_commit_time*3) / 4;
journal          1112 fs/jbd2/commit.c 		journal->j_average_commit_time = commit_time;
journal          1114 fs/jbd2/commit.c 	write_unlock(&journal->j_state_lock);
journal          1116 fs/jbd2/commit.c 	if (journal->j_commit_callback)
journal          1117 fs/jbd2/commit.c 		journal->j_commit_callback(journal, commit_transaction);
journal          1119 fs/jbd2/commit.c 	trace_jbd2_end_commit(journal, commit_transaction);
journal          1121 fs/jbd2/commit.c 		  journal->j_commit_sequence, journal->j_tail_sequence);
journal          1123 fs/jbd2/commit.c 	write_lock(&journal->j_state_lock);
journal          1124 fs/jbd2/commit.c 	spin_lock(&journal->j_list_lock);
journal          1129 fs/jbd2/commit.c 		__jbd2_journal_drop_transaction(journal, commit_transaction);
journal          1132 fs/jbd2/commit.c 	spin_unlock(&journal->j_list_lock);
journal          1133 fs/jbd2/commit.c 	write_unlock(&journal->j_state_lock);
journal          1134 fs/jbd2/commit.c 	wake_up(&journal->j_wait_done_commit);
journal          1139 fs/jbd2/commit.c 	spin_lock(&journal->j_history_lock);
journal          1140 fs/jbd2/commit.c 	journal->j_stats.ts_tid++;
journal          1141 fs/jbd2/commit.c 	journal->j_stats.ts_requested += stats.ts_requested;
journal          1142 fs/jbd2/commit.c 	journal->j_stats.run.rs_wait += stats.run.rs_wait;
journal          1143 fs/jbd2/commit.c 	journal->j_stats.run.rs_request_delay += stats.run.rs_request_delay;
journal          1144 fs/jbd2/commit.c 	journal->j_stats.run.rs_running += stats.run.rs_running;
journal          1145 fs/jbd2/commit.c 	journal->j_stats.run.rs_locked += stats.run.rs_locked;
journal          1146 fs/jbd2/commit.c 	journal->j_stats.run.rs_flushing += stats.run.rs_flushing;
journal          1147 fs/jbd2/commit.c 	journal->j_stats.run.rs_logging += stats.run.rs_logging;
journal          1148 fs/jbd2/commit.c 	journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count;
journal          1149 fs/jbd2/commit.c 	journal->j_stats.run.rs_blocks += stats.run.rs_blocks;
journal          1150 fs/jbd2/commit.c 	journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;
journal          1151 fs/jbd2/commit.c 	spin_unlock(&journal->j_history_lock);
journal            99 fs/jbd2/journal.c static void __journal_abort_soft (journal_t *journal, int errno);
journal           148 fs/jbd2/journal.c 	journal_t *journal = from_timer(journal, t, j_commit_timer);
journal           150 fs/jbd2/journal.c 	wake_up_process(journal->j_task);
journal           171 fs/jbd2/journal.c 	journal_t *journal = arg;
journal           178 fs/jbd2/journal.c 	timer_setup(&journal->j_commit_timer, commit_timeout, 0);
journal           183 fs/jbd2/journal.c 	journal->j_task = current;
journal           184 fs/jbd2/journal.c 	wake_up(&journal->j_wait_done_commit);
journal           197 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal           200 fs/jbd2/journal.c 	if (journal->j_flags & JBD2_UNMOUNT)
journal           204 fs/jbd2/journal.c 		journal->j_commit_sequence, journal->j_commit_request);
journal           206 fs/jbd2/journal.c 	if (journal->j_commit_sequence != journal->j_commit_request) {
journal           208 fs/jbd2/journal.c 		write_unlock(&journal->j_state_lock);
journal           209 fs/jbd2/journal.c 		del_timer_sync(&journal->j_commit_timer);
journal           210 fs/jbd2/journal.c 		jbd2_journal_commit_transaction(journal);
journal           211 fs/jbd2/journal.c 		write_lock(&journal->j_state_lock);
journal           215 fs/jbd2/journal.c 	wake_up(&journal->j_wait_done_commit);
journal           223 fs/jbd2/journal.c 		write_unlock(&journal->j_state_lock);
journal           225 fs/jbd2/journal.c 		write_lock(&journal->j_state_lock);
journal           234 fs/jbd2/journal.c 		prepare_to_wait(&journal->j_wait_commit, &wait,
journal           236 fs/jbd2/journal.c 		if (journal->j_commit_sequence != journal->j_commit_request)
journal           238 fs/jbd2/journal.c 		transaction = journal->j_running_transaction;
journal           242 fs/jbd2/journal.c 		if (journal->j_flags & JBD2_UNMOUNT)
journal           245 fs/jbd2/journal.c 			write_unlock(&journal->j_state_lock);
journal           247 fs/jbd2/journal.c 			write_lock(&journal->j_state_lock);
journal           249 fs/jbd2/journal.c 		finish_wait(&journal->j_wait_commit, &wait);
journal           257 fs/jbd2/journal.c 	transaction = journal->j_running_transaction;
journal           259 fs/jbd2/journal.c 		journal->j_commit_request = transaction->t_tid;
journal           265 fs/jbd2/journal.c 	del_timer_sync(&journal->j_commit_timer);
journal           266 fs/jbd2/journal.c 	journal->j_task = NULL;
journal           267 fs/jbd2/journal.c 	wake_up(&journal->j_wait_done_commit);
journal           269 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal           273 fs/jbd2/journal.c static int jbd2_journal_start_thread(journal_t *journal)
journal           277 fs/jbd2/journal.c 	t = kthread_run(kjournald2, journal, "jbd2/%s",
journal           278 fs/jbd2/journal.c 			journal->j_devname);
journal           282 fs/jbd2/journal.c 	wait_event(journal->j_wait_done_commit, journal->j_task != NULL);
journal           286 fs/jbd2/journal.c static void journal_kill_thread(journal_t *journal)
journal           288 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal           289 fs/jbd2/journal.c 	journal->j_flags |= JBD2_UNMOUNT;
journal           291 fs/jbd2/journal.c 	while (journal->j_task) {
journal           292 fs/jbd2/journal.c 		write_unlock(&journal->j_state_lock);
journal           293 fs/jbd2/journal.c 		wake_up(&journal->j_wait_commit);
journal           294 fs/jbd2/journal.c 		wait_event(journal->j_wait_done_commit, journal->j_task == NULL);
journal           295 fs/jbd2/journal.c 		write_lock(&journal->j_state_lock);
journal           297 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal           348 fs/jbd2/journal.c 	journal_t *journal = transaction->t_journal;
journal           449 fs/jbd2/journal.c 	new_bh->b_bdev = journal->j_dev;
journal           463 fs/jbd2/journal.c 	spin_lock(&journal->j_list_lock);
journal           465 fs/jbd2/journal.c 	spin_unlock(&journal->j_list_lock);
journal           481 fs/jbd2/journal.c int __jbd2_log_start_commit(journal_t *journal, tid_t target)
journal           484 fs/jbd2/journal.c 	if (journal->j_commit_request == target)
journal           492 fs/jbd2/journal.c 	if (journal->j_running_transaction &&
journal           493 fs/jbd2/journal.c 	    journal->j_running_transaction->t_tid == target) {
journal           499 fs/jbd2/journal.c 		journal->j_commit_request = target;
journal           501 fs/jbd2/journal.c 			  journal->j_commit_request,
journal           502 fs/jbd2/journal.c 			  journal->j_commit_sequence);
journal           503 fs/jbd2/journal.c 		journal->j_running_transaction->t_requested = jiffies;
journal           504 fs/jbd2/journal.c 		wake_up(&journal->j_wait_commit);
journal           506 fs/jbd2/journal.c 	} else if (!tid_geq(journal->j_commit_request, target))
journal           511 fs/jbd2/journal.c 			  journal->j_commit_request,
journal           512 fs/jbd2/journal.c 			  journal->j_commit_sequence,
journal           513 fs/jbd2/journal.c 			  target, journal->j_running_transaction ?
journal           514 fs/jbd2/journal.c 			  journal->j_running_transaction->t_tid : 0);
journal           518 fs/jbd2/journal.c int jbd2_log_start_commit(journal_t *journal, tid_t tid)
journal           522 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal           523 fs/jbd2/journal.c 	ret = __jbd2_log_start_commit(journal, tid);
journal           524 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal           535 fs/jbd2/journal.c static int __jbd2_journal_force_commit(journal_t *journal)
journal           541 fs/jbd2/journal.c 	read_lock(&journal->j_state_lock);
journal           542 fs/jbd2/journal.c 	if (journal->j_running_transaction && !current->journal_info) {
journal           543 fs/jbd2/journal.c 		transaction = journal->j_running_transaction;
journal           544 fs/jbd2/journal.c 		if (!tid_geq(journal->j_commit_request, transaction->t_tid))
journal           546 fs/jbd2/journal.c 	} else if (journal->j_committing_transaction)
journal           547 fs/jbd2/journal.c 		transaction = journal->j_committing_transaction;
journal           551 fs/jbd2/journal.c 		read_unlock(&journal->j_state_lock);
journal           555 fs/jbd2/journal.c 	read_unlock(&journal->j_state_lock);
journal           557 fs/jbd2/journal.c 		jbd2_log_start_commit(journal, tid);
journal           558 fs/jbd2/journal.c 	ret = jbd2_log_wait_commit(journal, tid);
journal           573 fs/jbd2/journal.c int jbd2_journal_force_commit_nested(journal_t *journal)
journal           577 fs/jbd2/journal.c 	ret = __jbd2_journal_force_commit(journal);
journal           588 fs/jbd2/journal.c int jbd2_journal_force_commit(journal_t *journal)
journal           593 fs/jbd2/journal.c 	ret = __jbd2_journal_force_commit(journal);
journal           604 fs/jbd2/journal.c int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
journal           608 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal           609 fs/jbd2/journal.c 	if (journal->j_running_transaction) {
journal           610 fs/jbd2/journal.c 		tid_t tid = journal->j_running_transaction->t_tid;
journal           612 fs/jbd2/journal.c 		__jbd2_log_start_commit(journal, tid);
journal           618 fs/jbd2/journal.c 	} else if (journal->j_committing_transaction) {
journal           624 fs/jbd2/journal.c 			*ptid = journal->j_committing_transaction->t_tid;
journal           627 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal           637 fs/jbd2/journal.c int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid)
journal           642 fs/jbd2/journal.c 	if (!(journal->j_flags & JBD2_BARRIER))
journal           644 fs/jbd2/journal.c 	read_lock(&journal->j_state_lock);
journal           646 fs/jbd2/journal.c 	if (tid_geq(journal->j_commit_sequence, tid))
journal           648 fs/jbd2/journal.c 	commit_trans = journal->j_committing_transaction;
journal           657 fs/jbd2/journal.c 	if (journal->j_fs_dev != journal->j_dev) {
journal           667 fs/jbd2/journal.c 	read_unlock(&journal->j_state_lock);
journal           676 fs/jbd2/journal.c int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
journal           680 fs/jbd2/journal.c 	read_lock(&journal->j_state_lock);
journal           687 fs/jbd2/journal.c 	if (tid_gt(tid, journal->j_commit_sequence) &&
journal           688 fs/jbd2/journal.c 	    (!journal->j_committing_transaction ||
journal           689 fs/jbd2/journal.c 	     journal->j_committing_transaction->t_tid != tid)) {
journal           690 fs/jbd2/journal.c 		read_unlock(&journal->j_state_lock);
journal           691 fs/jbd2/journal.c 		jbd2_might_wait_for_commit(journal);
journal           692 fs/jbd2/journal.c 		read_lock(&journal->j_state_lock);
journal           696 fs/jbd2/journal.c 	if (!tid_geq(journal->j_commit_request, tid)) {
journal           699 fs/jbd2/journal.c 		       __func__, journal->j_commit_request, tid);
journal           702 fs/jbd2/journal.c 	while (tid_gt(tid, journal->j_commit_sequence)) {
journal           704 fs/jbd2/journal.c 				  tid, journal->j_commit_sequence);
journal           705 fs/jbd2/journal.c 		read_unlock(&journal->j_state_lock);
journal           706 fs/jbd2/journal.c 		wake_up(&journal->j_wait_commit);
journal           707 fs/jbd2/journal.c 		wait_event(journal->j_wait_done_commit,
journal           708 fs/jbd2/journal.c 				!tid_gt(tid, journal->j_commit_sequence));
journal           709 fs/jbd2/journal.c 		read_lock(&journal->j_state_lock);
journal           711 fs/jbd2/journal.c 	read_unlock(&journal->j_state_lock);
journal           713 fs/jbd2/journal.c 	if (unlikely(is_journal_aborted(journal)))
journal           719 fs/jbd2/journal.c int jbd2_transaction_committed(journal_t *journal, tid_t tid)
journal           723 fs/jbd2/journal.c 	read_lock(&journal->j_state_lock);
journal           724 fs/jbd2/journal.c 	if (journal->j_running_transaction &&
journal           725 fs/jbd2/journal.c 	    journal->j_running_transaction->t_tid == tid)
journal           727 fs/jbd2/journal.c 	if (journal->j_committing_transaction &&
journal           728 fs/jbd2/journal.c 	    journal->j_committing_transaction->t_tid == tid)
journal           730 fs/jbd2/journal.c 	read_unlock(&journal->j_state_lock);
journal           742 fs/jbd2/journal.c int jbd2_complete_transaction(journal_t *journal, tid_t tid)
journal           746 fs/jbd2/journal.c 	read_lock(&journal->j_state_lock);
journal           747 fs/jbd2/journal.c 	if (journal->j_running_transaction &&
journal           748 fs/jbd2/journal.c 	    journal->j_running_transaction->t_tid == tid) {
journal           749 fs/jbd2/journal.c 		if (journal->j_commit_request != tid) {
journal           751 fs/jbd2/journal.c 			read_unlock(&journal->j_state_lock);
journal           752 fs/jbd2/journal.c 			jbd2_log_start_commit(journal, tid);
journal           755 fs/jbd2/journal.c 	} else if (!(journal->j_committing_transaction &&
journal           756 fs/jbd2/journal.c 		     journal->j_committing_transaction->t_tid == tid))
journal           758 fs/jbd2/journal.c 	read_unlock(&journal->j_state_lock);
journal           762 fs/jbd2/journal.c 	return jbd2_log_wait_commit(journal, tid);
journal           770 fs/jbd2/journal.c int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp)
journal           774 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal           775 fs/jbd2/journal.c 	J_ASSERT(journal->j_free > 1);
journal           777 fs/jbd2/journal.c 	blocknr = journal->j_head;
journal           778 fs/jbd2/journal.c 	journal->j_head++;
journal           779 fs/jbd2/journal.c 	journal->j_free--;
journal           780 fs/jbd2/journal.c 	if (journal->j_head == journal->j_last)
journal           781 fs/jbd2/journal.c 		journal->j_head = journal->j_first;
journal           782 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal           783 fs/jbd2/journal.c 	return jbd2_journal_bmap(journal, blocknr, retp);
journal           793 fs/jbd2/journal.c int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,
journal           799 fs/jbd2/journal.c 	if (journal->j_inode) {
journal           800 fs/jbd2/journal.c 		ret = bmap(journal->j_inode, blocknr);
journal           806 fs/jbd2/journal.c 			       __func__, blocknr, journal->j_devname);
journal           808 fs/jbd2/journal.c 			__journal_abort_soft(journal, err);
journal           829 fs/jbd2/journal.c 	journal_t *journal = transaction->t_journal;
journal           835 fs/jbd2/journal.c 	err = jbd2_journal_next_log_block(journal, &blocknr);
journal           840 fs/jbd2/journal.c 	bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
journal           844 fs/jbd2/journal.c 	memset(bh->b_data, 0, journal->j_blocksize);
journal           880 fs/jbd2/journal.c int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
journal           886 fs/jbd2/journal.c 	read_lock(&journal->j_state_lock);
journal           887 fs/jbd2/journal.c 	spin_lock(&journal->j_list_lock);
journal           888 fs/jbd2/journal.c 	transaction = journal->j_checkpoint_transactions;
journal           892 fs/jbd2/journal.c 	} else if ((transaction = journal->j_committing_transaction) != NULL) {
journal           895 fs/jbd2/journal.c 	} else if ((transaction = journal->j_running_transaction) != NULL) {
journal           897 fs/jbd2/journal.c 		*block = journal->j_head;
journal           899 fs/jbd2/journal.c 		*tid = journal->j_transaction_sequence;
journal           900 fs/jbd2/journal.c 		*block = journal->j_head;
journal           902 fs/jbd2/journal.c 	ret = tid_gt(*tid, journal->j_tail_sequence);
journal           903 fs/jbd2/journal.c 	spin_unlock(&journal->j_list_lock);
journal           904 fs/jbd2/journal.c 	read_unlock(&journal->j_state_lock);
journal           919 fs/jbd2/journal.c int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
journal           924 fs/jbd2/journal.c 	BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
journal           932 fs/jbd2/journal.c 	ret = jbd2_journal_update_sb_log_tail(journal, tid, block,
journal           937 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal           938 fs/jbd2/journal.c 	freed = block - journal->j_tail;
journal           939 fs/jbd2/journal.c 	if (block < journal->j_tail)
journal           940 fs/jbd2/journal.c 		freed += journal->j_last - journal->j_first;
journal           942 fs/jbd2/journal.c 	trace_jbd2_update_log_tail(journal, tid, block, freed);
journal           946 fs/jbd2/journal.c 		  journal->j_tail_sequence, tid, block, freed);
journal           948 fs/jbd2/journal.c 	journal->j_free += freed;
journal           949 fs/jbd2/journal.c 	journal->j_tail_sequence = tid;
journal           950 fs/jbd2/journal.c 	journal->j_tail = block;
journal           951 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal           962 fs/jbd2/journal.c void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
journal           964 fs/jbd2/journal.c 	mutex_lock_io(&journal->j_checkpoint_mutex);
journal           965 fs/jbd2/journal.c 	if (tid_gt(tid, journal->j_tail_sequence))
journal           966 fs/jbd2/journal.c 		__jbd2_update_log_tail(journal, tid, block);
journal           967 fs/jbd2/journal.c 	mutex_unlock(&journal->j_checkpoint_mutex);
journal           971 fs/jbd2/journal.c 	journal_t *journal;
journal           997 fs/jbd2/journal.c 		   s->journal->j_max_transaction_buffers);
journal          1015 fs/jbd2/journal.c 		   div_u64(s->journal->j_average_commit_time, 1000));
journal          1038 fs/jbd2/journal.c 	journal_t *journal = PDE_DATA(inode);
journal          1051 fs/jbd2/journal.c 	spin_lock(&journal->j_history_lock);
journal          1052 fs/jbd2/journal.c 	memcpy(s->stats, &journal->j_stats, size);
journal          1053 fs/jbd2/journal.c 	s->journal = journal;
journal          1054 fs/jbd2/journal.c 	spin_unlock(&journal->j_history_lock);
journal          1087 fs/jbd2/journal.c static void jbd2_stats_proc_init(journal_t *journal)
journal          1089 fs/jbd2/journal.c 	journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
journal          1090 fs/jbd2/journal.c 	if (journal->j_proc_entry) {
journal          1091 fs/jbd2/journal.c 		proc_create_data("info", S_IRUGO, journal->j_proc_entry,
journal          1092 fs/jbd2/journal.c 				 &jbd2_seq_info_fops, journal);
journal          1096 fs/jbd2/journal.c static void jbd2_stats_proc_exit(journal_t *journal)
journal          1098 fs/jbd2/journal.c 	remove_proc_entry("info", journal->j_proc_entry);
journal          1099 fs/jbd2/journal.c 	remove_proc_entry(journal->j_devname, proc_jbd2_stats);
journal          1116 fs/jbd2/journal.c 	journal_t *journal;
journal          1121 fs/jbd2/journal.c 	journal = kzalloc(sizeof(*journal), GFP_KERNEL);
journal          1122 fs/jbd2/journal.c 	if (!journal)
journal          1125 fs/jbd2/journal.c 	init_waitqueue_head(&journal->j_wait_transaction_locked);
journal          1126 fs/jbd2/journal.c 	init_waitqueue_head(&journal->j_wait_done_commit);
journal          1127 fs/jbd2/journal.c 	init_waitqueue_head(&journal->j_wait_commit);
journal          1128 fs/jbd2/journal.c 	init_waitqueue_head(&journal->j_wait_updates);
journal          1129 fs/jbd2/journal.c 	init_waitqueue_head(&journal->j_wait_reserved);
journal          1130 fs/jbd2/journal.c 	mutex_init(&journal->j_barrier);
journal          1131 fs/jbd2/journal.c 	mutex_init(&journal->j_checkpoint_mutex);
journal          1132 fs/jbd2/journal.c 	spin_lock_init(&journal->j_revoke_lock);
journal          1133 fs/jbd2/journal.c 	spin_lock_init(&journal->j_list_lock);
journal          1134 fs/jbd2/journal.c 	rwlock_init(&journal->j_state_lock);
journal          1136 fs/jbd2/journal.c 	journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE);
journal          1137 fs/jbd2/journal.c 	journal->j_min_batch_time = 0;
journal          1138 fs/jbd2/journal.c 	journal->j_max_batch_time = 15000; /* 15ms */
journal          1139 fs/jbd2/journal.c 	atomic_set(&journal->j_reserved_credits, 0);
journal          1142 fs/jbd2/journal.c 	journal->j_flags = JBD2_ABORT;
journal          1145 fs/jbd2/journal.c 	err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);
journal          1149 fs/jbd2/journal.c 	spin_lock_init(&journal->j_history_lock);
journal          1151 fs/jbd2/journal.c 	lockdep_init_map(&journal->j_trans_commit_map, "jbd2_handle",
journal          1155 fs/jbd2/journal.c 	journal->j_blocksize = blocksize;
journal          1156 fs/jbd2/journal.c 	journal->j_dev = bdev;
journal          1157 fs/jbd2/journal.c 	journal->j_fs_dev = fs_dev;
journal          1158 fs/jbd2/journal.c 	journal->j_blk_offset = start;
journal          1159 fs/jbd2/journal.c 	journal->j_maxlen = len;
journal          1160 fs/jbd2/journal.c 	n = journal->j_blocksize / sizeof(journal_block_tag_t);
journal          1161 fs/jbd2/journal.c 	journal->j_wbufsize = n;
journal          1162 fs/jbd2/journal.c 	journal->j_wbuf = kmalloc_array(n, sizeof(struct buffer_head *),
journal          1164 fs/jbd2/journal.c 	if (!journal->j_wbuf)
journal          1167 fs/jbd2/journal.c 	bh = getblk_unmovable(journal->j_dev, start, journal->j_blocksize);
journal          1173 fs/jbd2/journal.c 	journal->j_sb_buffer = bh;
journal          1174 fs/jbd2/journal.c 	journal->j_superblock = (journal_superblock_t *)bh->b_data;
journal          1176 fs/jbd2/journal.c 	return journal;
journal          1179 fs/jbd2/journal.c 	kfree(journal->j_wbuf);
journal          1180 fs/jbd2/journal.c 	jbd2_journal_destroy_revoke(journal);
journal          1181 fs/jbd2/journal.c 	kfree(journal);
journal          1212 fs/jbd2/journal.c 	journal_t *journal;
journal          1214 fs/jbd2/journal.c 	journal = journal_init_common(bdev, fs_dev, start, len, blocksize);
journal          1215 fs/jbd2/journal.c 	if (!journal)
journal          1218 fs/jbd2/journal.c 	bdevname(journal->j_dev, journal->j_devname);
journal          1219 fs/jbd2/journal.c 	strreplace(journal->j_devname, '/', '!');
journal          1220 fs/jbd2/journal.c 	jbd2_stats_proc_init(journal);
journal          1222 fs/jbd2/journal.c 	return journal;
journal          1235 fs/jbd2/journal.c 	journal_t *journal;
journal          1250 fs/jbd2/journal.c 	journal = journal_init_common(inode->i_sb->s_bdev, inode->i_sb->s_bdev,
journal          1253 fs/jbd2/journal.c 	if (!journal)
journal          1256 fs/jbd2/journal.c 	journal->j_inode = inode;
journal          1257 fs/jbd2/journal.c 	bdevname(journal->j_dev, journal->j_devname);
journal          1258 fs/jbd2/journal.c 	p = strreplace(journal->j_devname, '/', '!');
journal          1259 fs/jbd2/journal.c 	sprintf(p, "-%lu", journal->j_inode->i_ino);
journal          1260 fs/jbd2/journal.c 	jbd2_stats_proc_init(journal);
journal          1262 fs/jbd2/journal.c 	return journal;
journal          1270 fs/jbd2/journal.c static void journal_fail_superblock (journal_t *journal)
journal          1272 fs/jbd2/journal.c 	struct buffer_head *bh = journal->j_sb_buffer;
journal          1274 fs/jbd2/journal.c 	journal->j_sb_buffer = NULL;
journal          1284 fs/jbd2/journal.c static int journal_reset(journal_t *journal)
journal          1286 fs/jbd2/journal.c 	journal_superblock_t *sb = journal->j_superblock;
journal          1294 fs/jbd2/journal.c 		journal_fail_superblock(journal);
journal          1298 fs/jbd2/journal.c 	journal->j_first = first;
journal          1299 fs/jbd2/journal.c 	journal->j_last = last;
journal          1301 fs/jbd2/journal.c 	journal->j_head = first;
journal          1302 fs/jbd2/journal.c 	journal->j_tail = first;
journal          1303 fs/jbd2/journal.c 	journal->j_free = last - first;
journal          1305 fs/jbd2/journal.c 	journal->j_tail_sequence = journal->j_transaction_sequence;
journal          1306 fs/jbd2/journal.c 	journal->j_commit_sequence = journal->j_transaction_sequence - 1;
journal          1307 fs/jbd2/journal.c 	journal->j_commit_request = journal->j_commit_sequence;
journal          1309 fs/jbd2/journal.c 	journal->j_max_transaction_buffers = journal->j_maxlen / 4;
journal          1320 fs/jbd2/journal.c 			journal->j_tail, journal->j_tail_sequence,
journal          1321 fs/jbd2/journal.c 			journal->j_errno);
journal          1322 fs/jbd2/journal.c 		journal->j_flags |= JBD2_FLUSHED;
journal          1325 fs/jbd2/journal.c 		mutex_lock_io(&journal->j_checkpoint_mutex);
journal          1332 fs/jbd2/journal.c 		jbd2_journal_update_sb_log_tail(journal,
journal          1333 fs/jbd2/journal.c 						journal->j_tail_sequence,
journal          1334 fs/jbd2/journal.c 						journal->j_tail,
journal          1336 fs/jbd2/journal.c 		mutex_unlock(&journal->j_checkpoint_mutex);
journal          1338 fs/jbd2/journal.c 	return jbd2_journal_start_thread(journal);
journal          1345 fs/jbd2/journal.c static int jbd2_write_superblock(journal_t *journal, int write_flags)
journal          1347 fs/jbd2/journal.c 	struct buffer_head *bh = journal->j_sb_buffer;
journal          1348 fs/jbd2/journal.c 	journal_superblock_t *sb = journal->j_superblock;
journal          1355 fs/jbd2/journal.c 	trace_jbd2_write_superblock(journal, write_flags);
journal          1356 fs/jbd2/journal.c 	if (!(journal->j_flags & JBD2_BARRIER))
journal          1369 fs/jbd2/journal.c 		       journal->j_devname);
journal          1373 fs/jbd2/journal.c 	if (jbd2_journal_has_csum_v2or3(journal))
journal          1374 fs/jbd2/journal.c 		sb->s_checksum = jbd2_superblock_csum(journal, sb);
journal          1387 fs/jbd2/journal.c 		       journal->j_devname);
journal          1388 fs/jbd2/journal.c 		jbd2_journal_abort(journal, ret);
journal          1404 fs/jbd2/journal.c int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
journal          1407 fs/jbd2/journal.c 	journal_superblock_t *sb = journal->j_superblock;
journal          1410 fs/jbd2/journal.c 	if (is_journal_aborted(journal))
journal          1413 fs/jbd2/journal.c 	BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
journal          1417 fs/jbd2/journal.c 	lock_buffer(journal->j_sb_buffer);
journal          1421 fs/jbd2/journal.c 	ret = jbd2_write_superblock(journal, write_op);
journal          1426 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal          1428 fs/jbd2/journal.c 	journal->j_flags &= ~JBD2_FLUSHED;
journal          1429 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal          1443 fs/jbd2/journal.c static void jbd2_mark_journal_empty(journal_t *journal, int write_op)
journal          1445 fs/jbd2/journal.c 	journal_superblock_t *sb = journal->j_superblock;
journal          1447 fs/jbd2/journal.c 	BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
journal          1448 fs/jbd2/journal.c 	lock_buffer(journal->j_sb_buffer);
journal          1450 fs/jbd2/journal.c 		unlock_buffer(journal->j_sb_buffer);
journal          1455 fs/jbd2/journal.c 		  journal->j_tail_sequence);
journal          1457 fs/jbd2/journal.c 	sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
journal          1460 fs/jbd2/journal.c 	jbd2_write_superblock(journal, write_op);
journal          1463 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal          1464 fs/jbd2/journal.c 	journal->j_flags |= JBD2_FLUSHED;
journal          1465 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal          1476 fs/jbd2/journal.c void jbd2_journal_update_sb_errno(journal_t *journal)
journal          1478 fs/jbd2/journal.c 	journal_superblock_t *sb = journal->j_superblock;
journal          1481 fs/jbd2/journal.c 	lock_buffer(journal->j_sb_buffer);
journal          1482 fs/jbd2/journal.c 	errcode = journal->j_errno;
journal          1488 fs/jbd2/journal.c 	jbd2_write_superblock(journal, REQ_SYNC | REQ_FUA);
journal          1496 fs/jbd2/journal.c static int journal_get_superblock(journal_t *journal)
journal          1502 fs/jbd2/journal.c 	bh = journal->j_sb_buffer;
journal          1518 fs/jbd2/journal.c 	sb = journal->j_superblock;
journal          1523 fs/jbd2/journal.c 	    sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
journal          1530 fs/jbd2/journal.c 		journal->j_format_version = 1;
journal          1533 fs/jbd2/journal.c 		journal->j_format_version = 2;
journal          1540 fs/jbd2/journal.c 	if (be32_to_cpu(sb->s_maxlen) < journal->j_maxlen)
journal          1541 fs/jbd2/journal.c 		journal->j_maxlen = be32_to_cpu(sb->s_maxlen);
journal          1542 fs/jbd2/journal.c 	else if (be32_to_cpu(sb->s_maxlen) > journal->j_maxlen) {
journal          1548 fs/jbd2/journal.c 	    be32_to_cpu(sb->s_first) >= journal->j_maxlen) {
journal          1555 fs/jbd2/journal.c 	if (jbd2_has_feature_csum2(journal) &&
journal          1556 fs/jbd2/journal.c 	    jbd2_has_feature_csum3(journal)) {
journal          1563 fs/jbd2/journal.c 	if (jbd2_journal_has_csum_v2or3_feature(journal) &&
journal          1564 fs/jbd2/journal.c 	    jbd2_has_feature_checksum(journal)) {
journal          1571 fs/jbd2/journal.c 	if (!jbd2_verify_csum_type(journal, sb)) {
journal          1577 fs/jbd2/journal.c 	if (jbd2_journal_has_csum_v2or3_feature(journal)) {
journal          1578 fs/jbd2/journal.c 		journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
journal          1579 fs/jbd2/journal.c 		if (IS_ERR(journal->j_chksum_driver)) {
journal          1581 fs/jbd2/journal.c 			err = PTR_ERR(journal->j_chksum_driver);
journal          1582 fs/jbd2/journal.c 			journal->j_chksum_driver = NULL;
journal          1587 fs/jbd2/journal.c 	if (jbd2_journal_has_csum_v2or3(journal)) {
journal          1589 fs/jbd2/journal.c 		if (sb->s_checksum != jbd2_superblock_csum(journal, sb)) {
journal          1596 fs/jbd2/journal.c 		journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid,
journal          1605 fs/jbd2/journal.c 	journal_fail_superblock(journal);
journal          1614 fs/jbd2/journal.c static int load_superblock(journal_t *journal)
journal          1619 fs/jbd2/journal.c 	err = journal_get_superblock(journal);
journal          1623 fs/jbd2/journal.c 	sb = journal->j_superblock;
journal          1625 fs/jbd2/journal.c 	journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
journal          1626 fs/jbd2/journal.c 	journal->j_tail = be32_to_cpu(sb->s_start);
journal          1627 fs/jbd2/journal.c 	journal->j_first = be32_to_cpu(sb->s_first);
journal          1628 fs/jbd2/journal.c 	journal->j_last = be32_to_cpu(sb->s_maxlen);
journal          1629 fs/jbd2/journal.c 	journal->j_errno = be32_to_cpu(sb->s_errno);
journal          1643 fs/jbd2/journal.c int jbd2_journal_load(journal_t *journal)
journal          1648 fs/jbd2/journal.c 	err = load_superblock(journal);
journal          1652 fs/jbd2/journal.c 	sb = journal->j_superblock;
journal          1656 fs/jbd2/journal.c 	if (journal->j_format_version >= 2) {
journal          1676 fs/jbd2/journal.c 	if (jbd2_journal_recover(journal))
journal          1679 fs/jbd2/journal.c 	if (journal->j_failed_commit) {
journal          1681 fs/jbd2/journal.c 		       "is corrupt.\n", journal->j_failed_commit,
journal          1682 fs/jbd2/journal.c 		       journal->j_devname);
journal          1689 fs/jbd2/journal.c 	journal->j_flags &= ~JBD2_ABORT;
journal          1694 fs/jbd2/journal.c 	if (journal_reset(journal))
journal          1697 fs/jbd2/journal.c 	journal->j_flags |= JBD2_LOADED;
journal          1713 fs/jbd2/journal.c int jbd2_journal_destroy(journal_t *journal)
journal          1718 fs/jbd2/journal.c 	journal_kill_thread(journal);
journal          1721 fs/jbd2/journal.c 	if (journal->j_running_transaction)
journal          1722 fs/jbd2/journal.c 		jbd2_journal_commit_transaction(journal);
journal          1727 fs/jbd2/journal.c 	spin_lock(&journal->j_list_lock);
journal          1728 fs/jbd2/journal.c 	while (journal->j_checkpoint_transactions != NULL) {
journal          1729 fs/jbd2/journal.c 		spin_unlock(&journal->j_list_lock);
journal          1730 fs/jbd2/journal.c 		mutex_lock_io(&journal->j_checkpoint_mutex);
journal          1731 fs/jbd2/journal.c 		err = jbd2_log_do_checkpoint(journal);
journal          1732 fs/jbd2/journal.c 		mutex_unlock(&journal->j_checkpoint_mutex);
journal          1738 fs/jbd2/journal.c 			jbd2_journal_destroy_checkpoint(journal);
journal          1739 fs/jbd2/journal.c 			spin_lock(&journal->j_list_lock);
journal          1742 fs/jbd2/journal.c 		spin_lock(&journal->j_list_lock);
journal          1745 fs/jbd2/journal.c 	J_ASSERT(journal->j_running_transaction == NULL);
journal          1746 fs/jbd2/journal.c 	J_ASSERT(journal->j_committing_transaction == NULL);
journal          1747 fs/jbd2/journal.c 	J_ASSERT(journal->j_checkpoint_transactions == NULL);
journal          1748 fs/jbd2/journal.c 	spin_unlock(&journal->j_list_lock);
journal          1750 fs/jbd2/journal.c 	if (journal->j_sb_buffer) {
journal          1751 fs/jbd2/journal.c 		if (!is_journal_aborted(journal)) {
journal          1752 fs/jbd2/journal.c 			mutex_lock_io(&journal->j_checkpoint_mutex);
journal          1754 fs/jbd2/journal.c 			write_lock(&journal->j_state_lock);
journal          1755 fs/jbd2/journal.c 			journal->j_tail_sequence =
journal          1756 fs/jbd2/journal.c 				++journal->j_transaction_sequence;
journal          1757 fs/jbd2/journal.c 			write_unlock(&journal->j_state_lock);
journal          1759 fs/jbd2/journal.c 			jbd2_mark_journal_empty(journal,
journal          1761 fs/jbd2/journal.c 			mutex_unlock(&journal->j_checkpoint_mutex);
journal          1764 fs/jbd2/journal.c 		brelse(journal->j_sb_buffer);
journal          1767 fs/jbd2/journal.c 	if (journal->j_proc_entry)
journal          1768 fs/jbd2/journal.c 		jbd2_stats_proc_exit(journal);
journal          1769 fs/jbd2/journal.c 	iput(journal->j_inode);
journal          1770 fs/jbd2/journal.c 	if (journal->j_revoke)
journal          1771 fs/jbd2/journal.c 		jbd2_journal_destroy_revoke(journal);
journal          1772 fs/jbd2/journal.c 	if (journal->j_chksum_driver)
journal          1773 fs/jbd2/journal.c 		crypto_free_shash(journal->j_chksum_driver);
journal          1774 fs/jbd2/journal.c 	kfree(journal->j_wbuf);
journal          1775 fs/jbd2/journal.c 	kfree(journal);
journal          1792 fs/jbd2/journal.c int jbd2_journal_check_used_features (journal_t *journal, unsigned long compat,
journal          1800 fs/jbd2/journal.c 	if (journal->j_format_version == 0 &&
journal          1801 fs/jbd2/journal.c 	    journal_get_superblock(journal) != 0)
journal          1803 fs/jbd2/journal.c 	if (journal->j_format_version == 1)
journal          1806 fs/jbd2/journal.c 	sb = journal->j_superblock;
journal          1827 fs/jbd2/journal.c int jbd2_journal_check_available_features (journal_t *journal, unsigned long compat,
journal          1837 fs/jbd2/journal.c 	if (journal->j_format_version != 2)
journal          1860 fs/jbd2/journal.c int jbd2_journal_set_features (journal_t *journal, unsigned long compat,
journal          1869 fs/jbd2/journal.c 	if (jbd2_journal_check_used_features(journal, compat, ro, incompat))
journal          1872 fs/jbd2/journal.c 	if (!jbd2_journal_check_available_features(journal, compat, ro, incompat))
journal          1889 fs/jbd2/journal.c 	sb = journal->j_superblock;
journal          1892 fs/jbd2/journal.c 	if ((journal->j_chksum_driver == NULL) &&
journal          1894 fs/jbd2/journal.c 		journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
journal          1895 fs/jbd2/journal.c 		if (IS_ERR(journal->j_chksum_driver)) {
journal          1897 fs/jbd2/journal.c 			journal->j_chksum_driver = NULL;
journal          1901 fs/jbd2/journal.c 		journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid,
journal          1905 fs/jbd2/journal.c 	lock_buffer(journal->j_sb_buffer);
journal          1923 fs/jbd2/journal.c 	unlock_buffer(journal->j_sb_buffer);
journal          1941 fs/jbd2/journal.c void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,
journal          1949 fs/jbd2/journal.c 	sb = journal->j_superblock;
journal          1966 fs/jbd2/journal.c int jbd2_journal_flush(journal_t *journal)
journal          1971 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal          1974 fs/jbd2/journal.c 	if (journal->j_running_transaction) {
journal          1975 fs/jbd2/journal.c 		transaction = journal->j_running_transaction;
journal          1976 fs/jbd2/journal.c 		__jbd2_log_start_commit(journal, transaction->t_tid);
journal          1977 fs/jbd2/journal.c 	} else if (journal->j_committing_transaction)
journal          1978 fs/jbd2/journal.c 		transaction = journal->j_committing_transaction;
journal          1984 fs/jbd2/journal.c 		write_unlock(&journal->j_state_lock);
journal          1985 fs/jbd2/journal.c 		jbd2_log_wait_commit(journal, tid);
journal          1987 fs/jbd2/journal.c 		write_unlock(&journal->j_state_lock);
journal          1991 fs/jbd2/journal.c 	spin_lock(&journal->j_list_lock);
journal          1992 fs/jbd2/journal.c 	while (!err && journal->j_checkpoint_transactions != NULL) {
journal          1993 fs/jbd2/journal.c 		spin_unlock(&journal->j_list_lock);
journal          1994 fs/jbd2/journal.c 		mutex_lock_io(&journal->j_checkpoint_mutex);
journal          1995 fs/jbd2/journal.c 		err = jbd2_log_do_checkpoint(journal);
journal          1996 fs/jbd2/journal.c 		mutex_unlock(&journal->j_checkpoint_mutex);
journal          1997 fs/jbd2/journal.c 		spin_lock(&journal->j_list_lock);
journal          1999 fs/jbd2/journal.c 	spin_unlock(&journal->j_list_lock);
journal          2001 fs/jbd2/journal.c 	if (is_journal_aborted(journal))
journal          2004 fs/jbd2/journal.c 	mutex_lock_io(&journal->j_checkpoint_mutex);
journal          2006 fs/jbd2/journal.c 		err = jbd2_cleanup_journal_tail(journal);
journal          2008 fs/jbd2/journal.c 			mutex_unlock(&journal->j_checkpoint_mutex);
journal          2019 fs/jbd2/journal.c 	jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA);
journal          2020 fs/jbd2/journal.c 	mutex_unlock(&journal->j_checkpoint_mutex);
journal          2021 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal          2022 fs/jbd2/journal.c 	J_ASSERT(!journal->j_running_transaction);
journal          2023 fs/jbd2/journal.c 	J_ASSERT(!journal->j_committing_transaction);
journal          2024 fs/jbd2/journal.c 	J_ASSERT(!journal->j_checkpoint_transactions);
journal          2025 fs/jbd2/journal.c 	J_ASSERT(journal->j_head == journal->j_tail);
journal          2026 fs/jbd2/journal.c 	J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
journal          2027 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal          2045 fs/jbd2/journal.c int jbd2_journal_wipe(journal_t *journal, int write)
journal          2049 fs/jbd2/journal.c 	J_ASSERT (!(journal->j_flags & JBD2_LOADED));
journal          2051 fs/jbd2/journal.c 	err = load_superblock(journal);
journal          2055 fs/jbd2/journal.c 	if (!journal->j_tail)
journal          2061 fs/jbd2/journal.c 	err = jbd2_journal_skip_recovery(journal);
journal          2064 fs/jbd2/journal.c 		mutex_lock_io(&journal->j_checkpoint_mutex);
journal          2065 fs/jbd2/journal.c 		jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA);
journal          2066 fs/jbd2/journal.c 		mutex_unlock(&journal->j_checkpoint_mutex);
journal          2086 fs/jbd2/journal.c void __jbd2_journal_abort_hard(journal_t *journal)
journal          2090 fs/jbd2/journal.c 	if (journal->j_flags & JBD2_ABORT)
journal          2094 fs/jbd2/journal.c 	       journal->j_devname);
journal          2096 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal          2097 fs/jbd2/journal.c 	journal->j_flags |= JBD2_ABORT;
journal          2098 fs/jbd2/journal.c 	transaction = journal->j_running_transaction;
journal          2100 fs/jbd2/journal.c 		__jbd2_log_start_commit(journal, transaction->t_tid);
journal          2101 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal          2106 fs/jbd2/journal.c static void __journal_abort_soft (journal_t *journal, int errno)
journal          2110 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal          2111 fs/jbd2/journal.c 	old_errno = journal->j_errno;
journal          2112 fs/jbd2/journal.c 	if (!journal->j_errno || errno == -ESHUTDOWN)
journal          2113 fs/jbd2/journal.c 		journal->j_errno = errno;
journal          2115 fs/jbd2/journal.c 	if (journal->j_flags & JBD2_ABORT) {
journal          2116 fs/jbd2/journal.c 		write_unlock(&journal->j_state_lock);
journal          2118 fs/jbd2/journal.c 			jbd2_journal_update_sb_errno(journal);
journal          2121 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal          2123 fs/jbd2/journal.c 	__jbd2_journal_abort_hard(journal);
journal          2125 fs/jbd2/journal.c 	jbd2_journal_update_sb_errno(journal);
journal          2126 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal          2127 fs/jbd2/journal.c 	journal->j_flags |= JBD2_REC_ERR;
journal          2128 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal          2172 fs/jbd2/journal.c void jbd2_journal_abort(journal_t *journal, int errno)
journal          2174 fs/jbd2/journal.c 	__journal_abort_soft(journal, errno);
journal          2188 fs/jbd2/journal.c int jbd2_journal_errno(journal_t *journal)
journal          2192 fs/jbd2/journal.c 	read_lock(&journal->j_state_lock);
journal          2193 fs/jbd2/journal.c 	if (journal->j_flags & JBD2_ABORT)
journal          2196 fs/jbd2/journal.c 		err = journal->j_errno;
journal          2197 fs/jbd2/journal.c 	read_unlock(&journal->j_state_lock);
journal          2208 fs/jbd2/journal.c int jbd2_journal_clear_err(journal_t *journal)
journal          2212 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal          2213 fs/jbd2/journal.c 	if (journal->j_flags & JBD2_ABORT)
journal          2216 fs/jbd2/journal.c 		journal->j_errno = 0;
journal          2217 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal          2228 fs/jbd2/journal.c void jbd2_journal_ack_err(journal_t *journal)
journal          2230 fs/jbd2/journal.c 	write_lock(&journal->j_state_lock);
journal          2231 fs/jbd2/journal.c 	if (journal->j_errno)
journal          2232 fs/jbd2/journal.c 		journal->j_flags |= JBD2_ACK_ERR;
journal          2233 fs/jbd2/journal.c 	write_unlock(&journal->j_state_lock);
journal          2244 fs/jbd2/journal.c size_t journal_tag_bytes(journal_t *journal)
journal          2248 fs/jbd2/journal.c 	if (jbd2_has_feature_csum3(journal))
journal          2253 fs/jbd2/journal.c 	if (jbd2_has_feature_csum2(journal))
journal          2256 fs/jbd2/journal.c 	if (jbd2_has_feature_64bit(journal))
journal          2581 fs/jbd2/journal.c void jbd2_journal_release_jbd_inode(journal_t *journal,
journal          2584 fs/jbd2/journal.c 	if (!journal)
journal          2587 fs/jbd2/journal.c 	spin_lock(&journal->j_list_lock);
journal          2594 fs/jbd2/journal.c 		spin_unlock(&journal->j_list_lock);
journal          2604 fs/jbd2/journal.c 	spin_unlock(&journal->j_list_lock);
journal            39 fs/jbd2/recovery.c static int do_one_pass(journal_t *journal,
journal            67 fs/jbd2/recovery.c static int do_readahead(journal_t *journal, unsigned int start)
journal            77 fs/jbd2/recovery.c 	max = start + (128 * 1024 / journal->j_blocksize);
journal            78 fs/jbd2/recovery.c 	if (max > journal->j_maxlen)
journal            79 fs/jbd2/recovery.c 		max = journal->j_maxlen;
journal            87 fs/jbd2/recovery.c 		err = jbd2_journal_bmap(journal, next, &blocknr);
journal            95 fs/jbd2/recovery.c 		bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
journal           129 fs/jbd2/recovery.c static int jread(struct buffer_head **bhp, journal_t *journal,
journal           138 fs/jbd2/recovery.c 	if (offset >= journal->j_maxlen) {
journal           143 fs/jbd2/recovery.c 	err = jbd2_journal_bmap(journal, offset, &blocknr);
journal           151 fs/jbd2/recovery.c 	bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
journal           159 fs/jbd2/recovery.c 			do_readahead(journal, offset);
journal           197 fs/jbd2/recovery.c static int count_tags(journal_t *journal, struct buffer_head *bh)
journal           201 fs/jbd2/recovery.c 	int			nr = 0, size = journal->j_blocksize;
journal           202 fs/jbd2/recovery.c 	int			tag_bytes = journal_tag_bytes(journal);
journal           204 fs/jbd2/recovery.c 	if (jbd2_journal_has_csum_v2or3(journal))
journal           226 fs/jbd2/recovery.c #define wrap(journal, var)						\
journal           228 fs/jbd2/recovery.c 	if (var >= (journal)->j_last)					\
journal           229 fs/jbd2/recovery.c 		var -= ((journal)->j_last - (journal)->j_first);	\
journal           244 fs/jbd2/recovery.c int jbd2_journal_recover(journal_t *journal)
journal           252 fs/jbd2/recovery.c 	sb = journal->j_superblock;
journal           263 fs/jbd2/recovery.c 		journal->j_transaction_sequence = be32_to_cpu(sb->s_sequence) + 1;
journal           267 fs/jbd2/recovery.c 	err = do_one_pass(journal, &info, PASS_SCAN);
journal           269 fs/jbd2/recovery.c 		err = do_one_pass(journal, &info, PASS_REVOKE);
journal           271 fs/jbd2/recovery.c 		err = do_one_pass(journal, &info, PASS_REPLAY);
journal           281 fs/jbd2/recovery.c 	journal->j_transaction_sequence = ++info.end_transaction;
journal           283 fs/jbd2/recovery.c 	jbd2_journal_clear_revoke(journal);
journal           284 fs/jbd2/recovery.c 	err2 = sync_blockdev(journal->j_fs_dev);
journal           288 fs/jbd2/recovery.c 	if (journal->j_flags & JBD2_BARRIER) {
journal           289 fs/jbd2/recovery.c 		err2 = blkdev_issue_flush(journal->j_fs_dev, GFP_KERNEL, NULL);
journal           309 fs/jbd2/recovery.c int jbd2_journal_skip_recovery(journal_t *journal)
journal           317 fs/jbd2/recovery.c 	err = do_one_pass(journal, &info, PASS_SCAN);
journal           321 fs/jbd2/recovery.c 		++journal->j_transaction_sequence;
journal           325 fs/jbd2/recovery.c 			be32_to_cpu(journal->j_superblock->s_sequence);
journal           330 fs/jbd2/recovery.c 		journal->j_transaction_sequence = ++info.end_transaction;
journal           333 fs/jbd2/recovery.c 	journal->j_tail = 0;
journal           337 fs/jbd2/recovery.c static inline unsigned long long read_tag_block(journal_t *journal,
journal           341 fs/jbd2/recovery.c 	if (jbd2_has_feature_64bit(journal))
journal           350 fs/jbd2/recovery.c static int calc_chksums(journal_t *journal, struct buffer_head *bh,
journal           357 fs/jbd2/recovery.c 	num_blks = count_tags(journal, bh);
journal           363 fs/jbd2/recovery.c 		wrap(journal, *next_log_block);
journal           364 fs/jbd2/recovery.c 		err = jread(&obh, journal, io_block);
journal           416 fs/jbd2/recovery.c static int do_one_pass(journal_t *journal,
journal           427 fs/jbd2/recovery.c 	int			tag_bytes = journal_tag_bytes(journal);
journal           438 fs/jbd2/recovery.c 	sb = journal->j_superblock;
journal           473 fs/jbd2/recovery.c 			  next_commit_ID, next_log_block, journal->j_last);
journal           480 fs/jbd2/recovery.c 		err = jread(&bh, journal, next_log_block);
journal           485 fs/jbd2/recovery.c 		wrap(journal, next_log_block);
journal           517 fs/jbd2/recovery.c 			if (jbd2_journal_has_csum_v2or3(journal))
journal           521 fs/jbd2/recovery.c 			    !jbd2_descriptor_block_csum_verify(journal,
journal           537 fs/jbd2/recovery.c 				    jbd2_has_feature_checksum(journal) &&
journal           539 fs/jbd2/recovery.c 					if (calc_chksums(journal, bh,
journal           548 fs/jbd2/recovery.c 				next_log_block += count_tags(journal, bh);
journal           549 fs/jbd2/recovery.c 				wrap(journal, next_log_block);
journal           560 fs/jbd2/recovery.c 			       <= journal->j_blocksize - descr_csum_size) {
journal           567 fs/jbd2/recovery.c 				wrap(journal, next_log_block);
journal           568 fs/jbd2/recovery.c 				err = jread(&obh, journal, io_block);
journal           581 fs/jbd2/recovery.c 					blocknr = read_tag_block(journal,
journal           588 fs/jbd2/recovery.c 					    (journal, blocknr,
journal           597 fs/jbd2/recovery.c 						journal, tag, obh->b_data,
journal           611 fs/jbd2/recovery.c 					nbh = __getblk(journal->j_fs_dev,
journal           613 fs/jbd2/recovery.c 							journal->j_blocksize);
journal           626 fs/jbd2/recovery.c 							journal->j_blocksize);
journal           692 fs/jbd2/recovery.c 			    jbd2_has_feature_checksum(journal)) {
journal           702 fs/jbd2/recovery.c 					journal->j_failed_commit =
journal           732 fs/jbd2/recovery.c 					if (!jbd2_has_feature_async_commit(journal)) {
journal           733 fs/jbd2/recovery.c 						journal->j_failed_commit =
journal           742 fs/jbd2/recovery.c 			    !jbd2_commit_block_csum_verify(journal,
journal           746 fs/jbd2/recovery.c 				if (!jbd2_has_feature_async_commit(journal)) {
journal           747 fs/jbd2/recovery.c 					journal->j_failed_commit =
journal           765 fs/jbd2/recovery.c 			err = scan_revoke_records(journal, bh,
journal           812 fs/jbd2/recovery.c static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,
journal           825 fs/jbd2/recovery.c 	if (!jbd2_descriptor_block_csum_verify(journal, header))
journal           828 fs/jbd2/recovery.c 	if (jbd2_journal_has_csum_v2or3(journal))
journal           830 fs/jbd2/recovery.c 	if (rcount > journal->j_blocksize - csum_size)
journal           834 fs/jbd2/recovery.c 	if (jbd2_has_feature_64bit(journal))
journal           846 fs/jbd2/recovery.c 		err = jbd2_journal_set_revoke(journal, blocknr, sequence);
journal           131 fs/jbd2/revoke.c static inline int hash(journal_t *journal, unsigned long long block)
journal           133 fs/jbd2/revoke.c 	return hash_64(block, journal->j_revoke->hash_shift);
journal           136 fs/jbd2/revoke.c static int insert_revoke_hash(journal_t *journal, unsigned long long blocknr,
journal           151 fs/jbd2/revoke.c 	hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
journal           152 fs/jbd2/revoke.c 	spin_lock(&journal->j_revoke_lock);
journal           154 fs/jbd2/revoke.c 	spin_unlock(&journal->j_revoke_lock);
journal           160 fs/jbd2/revoke.c static struct jbd2_revoke_record_s *find_revoke_record(journal_t *journal,
journal           166 fs/jbd2/revoke.c 	hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
journal           168 fs/jbd2/revoke.c 	spin_lock(&journal->j_revoke_lock);
journal           172 fs/jbd2/revoke.c 			spin_unlock(&journal->j_revoke_lock);
journal           177 fs/jbd2/revoke.c 	spin_unlock(&journal->j_revoke_lock);
journal           263 fs/jbd2/revoke.c int jbd2_journal_init_revoke(journal_t *journal, int hash_size)
journal           265 fs/jbd2/revoke.c 	J_ASSERT(journal->j_revoke_table[0] == NULL);
journal           268 fs/jbd2/revoke.c 	journal->j_revoke_table[0] = jbd2_journal_init_revoke_table(hash_size);
journal           269 fs/jbd2/revoke.c 	if (!journal->j_revoke_table[0])
journal           272 fs/jbd2/revoke.c 	journal->j_revoke_table[1] = jbd2_journal_init_revoke_table(hash_size);
journal           273 fs/jbd2/revoke.c 	if (!journal->j_revoke_table[1])
journal           276 fs/jbd2/revoke.c 	journal->j_revoke = journal->j_revoke_table[1];
journal           278 fs/jbd2/revoke.c 	spin_lock_init(&journal->j_revoke_lock);
journal           283 fs/jbd2/revoke.c 	jbd2_journal_destroy_revoke_table(journal->j_revoke_table[0]);
journal           284 fs/jbd2/revoke.c 	journal->j_revoke_table[0] = NULL;
journal           290 fs/jbd2/revoke.c void jbd2_journal_destroy_revoke(journal_t *journal)
journal           292 fs/jbd2/revoke.c 	journal->j_revoke = NULL;
journal           293 fs/jbd2/revoke.c 	if (journal->j_revoke_table[0])
journal           294 fs/jbd2/revoke.c 		jbd2_journal_destroy_revoke_table(journal->j_revoke_table[0]);
journal           295 fs/jbd2/revoke.c 	if (journal->j_revoke_table[1])
journal           296 fs/jbd2/revoke.c 		jbd2_journal_destroy_revoke_table(journal->j_revoke_table[1]);
journal           330 fs/jbd2/revoke.c 	journal_t *journal;
journal           338 fs/jbd2/revoke.c 	journal = handle->h_transaction->t_journal;
journal           339 fs/jbd2/revoke.c 	if (!jbd2_journal_set_features(journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)){
journal           344 fs/jbd2/revoke.c 	bdev = journal->j_fs_dev;
journal           348 fs/jbd2/revoke.c 		bh = __find_get_block(bdev, blocknr, journal->j_blocksize);
journal           358 fs/jbd2/revoke.c 		bh2 = __find_get_block(bdev, blocknr, journal->j_blocksize);
journal           396 fs/jbd2/revoke.c 	err = insert_revoke_hash(journal, blocknr,
journal           420 fs/jbd2/revoke.c 	journal_t *journal = handle->h_transaction->t_journal;
journal           439 fs/jbd2/revoke.c 		record = find_revoke_record(journal, bh->b_blocknr);
journal           443 fs/jbd2/revoke.c 			spin_lock(&journal->j_revoke_lock);
journal           445 fs/jbd2/revoke.c 			spin_unlock(&journal->j_revoke_lock);
journal           453 fs/jbd2/revoke.c 	record = find_revoke_record(journal, bh->b_blocknr);
journal           478 fs/jbd2/revoke.c void jbd2_clear_buffer_revoked_flags(journal_t *journal)
journal           480 fs/jbd2/revoke.c 	struct jbd2_revoke_table_s *revoke = journal->j_revoke;
journal           492 fs/jbd2/revoke.c 			bh = __find_get_block(journal->j_fs_dev,
journal           494 fs/jbd2/revoke.c 					      journal->j_blocksize);
journal           507 fs/jbd2/revoke.c void jbd2_journal_switch_revoke_table(journal_t *journal)
journal           511 fs/jbd2/revoke.c 	if (journal->j_revoke == journal->j_revoke_table[0])
journal           512 fs/jbd2/revoke.c 		journal->j_revoke = journal->j_revoke_table[1];
journal           514 fs/jbd2/revoke.c 		journal->j_revoke = journal->j_revoke_table[0];
journal           516 fs/jbd2/revoke.c 	for (i = 0; i < journal->j_revoke->hash_size; i++)
journal           517 fs/jbd2/revoke.c 		INIT_LIST_HEAD(&journal->j_revoke->hash_table[i]);
journal           527 fs/jbd2/revoke.c 	journal_t *journal = transaction->t_journal;
journal           539 fs/jbd2/revoke.c 	revoke = journal->j_revoke == journal->j_revoke_table[0] ?
journal           540 fs/jbd2/revoke.c 		journal->j_revoke_table[1] : journal->j_revoke_table[0];
journal           556 fs/jbd2/revoke.c 		flush_descriptor(journal, descriptor, offset);
journal           571 fs/jbd2/revoke.c 	journal_t *journal = transaction->t_journal;
journal           580 fs/jbd2/revoke.c 	if (is_journal_aborted(journal))
journal           587 fs/jbd2/revoke.c 	if (jbd2_journal_has_csum_v2or3(journal))
journal           590 fs/jbd2/revoke.c 	if (jbd2_has_feature_64bit(journal))
journal           597 fs/jbd2/revoke.c 		if (offset + sz > journal->j_blocksize - csum_size) {
journal           598 fs/jbd2/revoke.c 			flush_descriptor(journal, descriptor, offset);
journal           617 fs/jbd2/revoke.c 	if (jbd2_has_feature_64bit(journal))
journal           635 fs/jbd2/revoke.c static void flush_descriptor(journal_t *journal,
journal           641 fs/jbd2/revoke.c 	if (is_journal_aborted(journal))
journal           646 fs/jbd2/revoke.c 	jbd2_descriptor_block_csum_set(journal, descriptor);
journal           677 fs/jbd2/revoke.c int jbd2_journal_set_revoke(journal_t *journal,
journal           683 fs/jbd2/revoke.c 	record = find_revoke_record(journal, blocknr);
journal           691 fs/jbd2/revoke.c 	return insert_revoke_hash(journal, blocknr, sequence);
journal           701 fs/jbd2/revoke.c int jbd2_journal_test_revoke(journal_t *journal,
journal           707 fs/jbd2/revoke.c 	record = find_revoke_record(journal, blocknr);
journal           720 fs/jbd2/revoke.c void jbd2_journal_clear_revoke(journal_t *journal)
journal           727 fs/jbd2/revoke.c 	revoke = journal->j_revoke;
journal            80 fs/jbd2/transaction.c static void jbd2_get_transaction(journal_t *journal,
journal            83 fs/jbd2/transaction.c 	transaction->t_journal = journal;
journal            86 fs/jbd2/transaction.c 	transaction->t_tid = journal->j_transaction_sequence++;
journal            87 fs/jbd2/transaction.c 	transaction->t_expires = jiffies + journal->j_commit_interval;
journal            91 fs/jbd2/transaction.c 		   atomic_read(&journal->j_reserved_credits));
journal            97 fs/jbd2/transaction.c 	journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires);
journal            98 fs/jbd2/transaction.c 	add_timer(&journal->j_commit_timer);
journal           100 fs/jbd2/transaction.c 	J_ASSERT(journal->j_running_transaction == NULL);
journal           101 fs/jbd2/transaction.c 	journal->j_running_transaction = transaction;
journal           145 fs/jbd2/transaction.c static void wait_transaction_locked(journal_t *journal)
journal           146 fs/jbd2/transaction.c 	__releases(journal->j_state_lock)
journal           150 fs/jbd2/transaction.c 	tid_t tid = journal->j_running_transaction->t_tid;
journal           152 fs/jbd2/transaction.c 	prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
journal           154 fs/jbd2/transaction.c 	need_to_start = !tid_geq(journal->j_commit_request, tid);
journal           155 fs/jbd2/transaction.c 	read_unlock(&journal->j_state_lock);
journal           157 fs/jbd2/transaction.c 		jbd2_log_start_commit(journal, tid);
journal           158 fs/jbd2/transaction.c 	jbd2_might_wait_for_commit(journal);
journal           160 fs/jbd2/transaction.c 	finish_wait(&journal->j_wait_transaction_locked, &wait);
journal           168 fs/jbd2/transaction.c static void wait_transaction_switching(journal_t *journal)
journal           169 fs/jbd2/transaction.c 	__releases(journal->j_state_lock)
journal           173 fs/jbd2/transaction.c 	if (WARN_ON(!journal->j_running_transaction ||
journal           174 fs/jbd2/transaction.c 		    journal->j_running_transaction->t_state != T_SWITCH))
journal           176 fs/jbd2/transaction.c 	prepare_to_wait(&journal->j_wait_transaction_locked, &wait,
journal           178 fs/jbd2/transaction.c 	read_unlock(&journal->j_state_lock);
journal           186 fs/jbd2/transaction.c 	finish_wait(&journal->j_wait_transaction_locked, &wait);
journal           189 fs/jbd2/transaction.c static void sub_reserved_credits(journal_t *journal, int blocks)
journal           191 fs/jbd2/transaction.c 	atomic_sub(blocks, &journal->j_reserved_credits);
journal           192 fs/jbd2/transaction.c 	wake_up(&journal->j_wait_reserved);
journal           201 fs/jbd2/transaction.c static int add_transaction_credits(journal_t *journal, int blocks,
journal           204 fs/jbd2/transaction.c 	transaction_t *t = journal->j_running_transaction;
journal           214 fs/jbd2/transaction.c 		wait_transaction_locked(journal);
journal           224 fs/jbd2/transaction.c 	if (needed > journal->j_max_transaction_buffers) {
journal           236 fs/jbd2/transaction.c 		if (atomic_read(&journal->j_reserved_credits) + total >
journal           237 fs/jbd2/transaction.c 		    journal->j_max_transaction_buffers) {
journal           238 fs/jbd2/transaction.c 			read_unlock(&journal->j_state_lock);
journal           239 fs/jbd2/transaction.c 			jbd2_might_wait_for_commit(journal);
journal           240 fs/jbd2/transaction.c 			wait_event(journal->j_wait_reserved,
journal           241 fs/jbd2/transaction.c 				   atomic_read(&journal->j_reserved_credits) + total <=
journal           242 fs/jbd2/transaction.c 				   journal->j_max_transaction_buffers);
journal           246 fs/jbd2/transaction.c 		wait_transaction_locked(journal);
journal           261 fs/jbd2/transaction.c 	if (jbd2_log_space_left(journal) < jbd2_space_needed(journal)) {
journal           263 fs/jbd2/transaction.c 		read_unlock(&journal->j_state_lock);
journal           264 fs/jbd2/transaction.c 		jbd2_might_wait_for_commit(journal);
journal           265 fs/jbd2/transaction.c 		write_lock(&journal->j_state_lock);
journal           266 fs/jbd2/transaction.c 		if (jbd2_log_space_left(journal) < jbd2_space_needed(journal))
journal           267 fs/jbd2/transaction.c 			__jbd2_log_wait_for_space(journal);
journal           268 fs/jbd2/transaction.c 		write_unlock(&journal->j_state_lock);
journal           276 fs/jbd2/transaction.c 	needed = atomic_add_return(rsv_blocks, &journal->j_reserved_credits);
journal           278 fs/jbd2/transaction.c 	if (needed > journal->j_max_transaction_buffers / 2) {
journal           279 fs/jbd2/transaction.c 		sub_reserved_credits(journal, rsv_blocks);
journal           281 fs/jbd2/transaction.c 		read_unlock(&journal->j_state_lock);
journal           282 fs/jbd2/transaction.c 		jbd2_might_wait_for_commit(journal);
journal           283 fs/jbd2/transaction.c 		wait_event(journal->j_wait_reserved,
journal           284 fs/jbd2/transaction.c 			 atomic_read(&journal->j_reserved_credits) + rsv_blocks
journal           285 fs/jbd2/transaction.c 			 <= journal->j_max_transaction_buffers / 2);
journal           298 fs/jbd2/transaction.c static int start_this_handle(journal_t *journal, handle_t *handle,
journal           314 fs/jbd2/transaction.c 	if ((rsv_blocks > journal->j_max_transaction_buffers / 2) ||
journal           315 fs/jbd2/transaction.c 	    (rsv_blocks + blocks > journal->j_max_transaction_buffers)) {
journal           319 fs/jbd2/transaction.c 		       journal->j_max_transaction_buffers);
journal           325 fs/jbd2/transaction.c 	if (!journal->j_running_transaction) {
journal           345 fs/jbd2/transaction.c 	read_lock(&journal->j_state_lock);
journal           346 fs/jbd2/transaction.c 	BUG_ON(journal->j_flags & JBD2_UNMOUNT);
journal           347 fs/jbd2/transaction.c 	if (is_journal_aborted(journal) ||
journal           348 fs/jbd2/transaction.c 	    (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) {
journal           349 fs/jbd2/transaction.c 		read_unlock(&journal->j_state_lock);
journal           359 fs/jbd2/transaction.c 	if (!handle->h_reserved && journal->j_barrier_count) {
journal           360 fs/jbd2/transaction.c 		read_unlock(&journal->j_state_lock);
journal           361 fs/jbd2/transaction.c 		wait_event(journal->j_wait_transaction_locked,
journal           362 fs/jbd2/transaction.c 				journal->j_barrier_count == 0);
journal           366 fs/jbd2/transaction.c 	if (!journal->j_running_transaction) {
journal           367 fs/jbd2/transaction.c 		read_unlock(&journal->j_state_lock);
journal           370 fs/jbd2/transaction.c 		write_lock(&journal->j_state_lock);
journal           371 fs/jbd2/transaction.c 		if (!journal->j_running_transaction &&
journal           372 fs/jbd2/transaction.c 		    (handle->h_reserved || !journal->j_barrier_count)) {
journal           373 fs/jbd2/transaction.c 			jbd2_get_transaction(journal, new_transaction);
journal           376 fs/jbd2/transaction.c 		write_unlock(&journal->j_state_lock);
journal           380 fs/jbd2/transaction.c 	transaction = journal->j_running_transaction;
journal           384 fs/jbd2/transaction.c 		if (add_transaction_credits(journal, blocks, rsv_blocks))
journal           395 fs/jbd2/transaction.c 			wait_transaction_switching(journal);
journal           398 fs/jbd2/transaction.c 		sub_reserved_credits(journal, blocks);
journal           414 fs/jbd2/transaction.c 		  jbd2_log_space_left(journal));
journal           415 fs/jbd2/transaction.c 	read_unlock(&journal->j_state_lock);
journal           418 fs/jbd2/transaction.c 	rwsem_acquire_read(&journal->j_trans_commit_map, 0, 0, _THIS_IP_);
journal           440 fs/jbd2/transaction.c handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks,
journal           447 fs/jbd2/transaction.c 	if (!journal)
journal           451 fs/jbd2/transaction.c 		J_ASSERT(handle->h_transaction->t_journal == journal);
journal           468 fs/jbd2/transaction.c 		rsv_handle->h_journal = journal;
journal           472 fs/jbd2/transaction.c 	err = start_this_handle(journal, handle, gfp_mask);
journal           481 fs/jbd2/transaction.c 	trace_jbd2_handle_start(journal->j_fs_dev->bd_dev,
journal           509 fs/jbd2/transaction.c handle_t *jbd2_journal_start(journal_t *journal, int nblocks)
journal           511 fs/jbd2/transaction.c 	return jbd2__journal_start(journal, nblocks, 0, GFP_NOFS, 0, 0);
journal           517 fs/jbd2/transaction.c 	journal_t *journal = handle->h_journal;
journal           520 fs/jbd2/transaction.c 	sub_reserved_credits(journal, handle->h_buffer_credits);
journal           542 fs/jbd2/transaction.c 	journal_t *journal = handle->h_journal;
journal           564 fs/jbd2/transaction.c 	ret = start_this_handle(journal, handle, GFP_NOFS);
journal           566 fs/jbd2/transaction.c 		handle->h_journal = journal;
journal           572 fs/jbd2/transaction.c 	trace_jbd2_handle_start(journal->j_fs_dev->bd_dev,
journal           602 fs/jbd2/transaction.c 	journal_t *journal;
journal           608 fs/jbd2/transaction.c 	journal = transaction->t_journal;
journal           612 fs/jbd2/transaction.c 	read_lock(&journal->j_state_lock);
journal           625 fs/jbd2/transaction.c 	if (wanted > journal->j_max_transaction_buffers) {
journal           633 fs/jbd2/transaction.c 	    jbd2_log_space_left(journal)) {
journal           640 fs/jbd2/transaction.c 	trace_jbd2_handle_extend(journal->j_fs_dev->bd_dev,
journal           654 fs/jbd2/transaction.c 	read_unlock(&journal->j_state_lock);
journal           678 fs/jbd2/transaction.c 	journal_t *journal;
journal           686 fs/jbd2/transaction.c 	journal = transaction->t_journal;
journal           695 fs/jbd2/transaction.c 	read_lock(&journal->j_state_lock);
journal           700 fs/jbd2/transaction.c 		sub_reserved_credits(journal,
journal           704 fs/jbd2/transaction.c 		wake_up(&journal->j_wait_updates);
journal           711 fs/jbd2/transaction.c 	need_to_start = !tid_geq(journal->j_commit_request, tid);
journal           712 fs/jbd2/transaction.c 	read_unlock(&journal->j_state_lock);
journal           714 fs/jbd2/transaction.c 		jbd2_log_start_commit(journal, tid);
journal           716 fs/jbd2/transaction.c 	rwsem_release(&journal->j_trans_commit_map, 1, _THIS_IP_);
journal           724 fs/jbd2/transaction.c 	ret = start_this_handle(journal, handle, gfp_mask);
journal           746 fs/jbd2/transaction.c void jbd2_journal_lock_updates(journal_t *journal)
journal           750 fs/jbd2/transaction.c 	jbd2_might_wait_for_commit(journal);
journal           752 fs/jbd2/transaction.c 	write_lock(&journal->j_state_lock);
journal           753 fs/jbd2/transaction.c 	++journal->j_barrier_count;
journal           756 fs/jbd2/transaction.c 	if (atomic_read(&journal->j_reserved_credits)) {
journal           757 fs/jbd2/transaction.c 		write_unlock(&journal->j_state_lock);
journal           758 fs/jbd2/transaction.c 		wait_event(journal->j_wait_reserved,
journal           759 fs/jbd2/transaction.c 			   atomic_read(&journal->j_reserved_credits) == 0);
journal           760 fs/jbd2/transaction.c 		write_lock(&journal->j_state_lock);
journal           765 fs/jbd2/transaction.c 		transaction_t *transaction = journal->j_running_transaction;
journal           771 fs/jbd2/transaction.c 		prepare_to_wait(&journal->j_wait_updates, &wait,
journal           775 fs/jbd2/transaction.c 			finish_wait(&journal->j_wait_updates, &wait);
journal           779 fs/jbd2/transaction.c 		write_unlock(&journal->j_state_lock);
journal           781 fs/jbd2/transaction.c 		finish_wait(&journal->j_wait_updates, &wait);
journal           782 fs/jbd2/transaction.c 		write_lock(&journal->j_state_lock);
journal           784 fs/jbd2/transaction.c 	write_unlock(&journal->j_state_lock);
journal           792 fs/jbd2/transaction.c 	mutex_lock(&journal->j_barrier);
journal           803 fs/jbd2/transaction.c void jbd2_journal_unlock_updates (journal_t *journal)
journal           805 fs/jbd2/transaction.c 	J_ASSERT(journal->j_barrier_count != 0);
journal           807 fs/jbd2/transaction.c 	mutex_unlock(&journal->j_barrier);
journal           808 fs/jbd2/transaction.c 	write_lock(&journal->j_state_lock);
journal           809 fs/jbd2/transaction.c 	--journal->j_barrier_count;
journal           810 fs/jbd2/transaction.c 	write_unlock(&journal->j_state_lock);
journal           811 fs/jbd2/transaction.c 	wake_up(&journal->j_wait_transaction_locked);
journal           863 fs/jbd2/transaction.c 	journal_t *journal;
journal           868 fs/jbd2/transaction.c 	journal = transaction->t_journal;
journal           910 fs/jbd2/transaction.c 					journal->j_committing_transaction);
journal           964 fs/jbd2/transaction.c 		spin_lock(&journal->j_list_lock);
journal           966 fs/jbd2/transaction.c 		spin_unlock(&journal->j_list_lock);
journal           981 fs/jbd2/transaction.c 	J_ASSERT_JH(jh, jh->b_transaction == journal->j_committing_transaction);
journal          1157 fs/jbd2/transaction.c 	journal_t *journal;
journal          1165 fs/jbd2/transaction.c 	journal = transaction->t_journal;
journal          1179 fs/jbd2/transaction.c 		(jh->b_transaction == journal->j_committing_transaction &&
journal          1199 fs/jbd2/transaction.c 		spin_lock(&journal->j_list_lock);
journal          1201 fs/jbd2/transaction.c 		spin_unlock(&journal->j_list_lock);
journal          1202 fs/jbd2/transaction.c 	} else if (jh->b_transaction == journal->j_committing_transaction) {
journal          1207 fs/jbd2/transaction.c 		spin_lock(&journal->j_list_lock);
journal          1209 fs/jbd2/transaction.c 		spin_unlock(&journal->j_list_lock);
journal          1372 fs/jbd2/transaction.c 	journal_t *journal;
journal          1421 fs/jbd2/transaction.c 	journal = transaction->t_journal;
journal          1448 fs/jbd2/transaction.c 			     journal->j_running_transaction)) {
journal          1452 fs/jbd2/transaction.c 			       journal->j_devname,
journal          1456 fs/jbd2/transaction.c 			       journal->j_running_transaction,
journal          1457 fs/jbd2/transaction.c 			       journal->j_running_transaction ?
journal          1458 fs/jbd2/transaction.c 			       journal->j_running_transaction->t_tid : 0);
journal          1475 fs/jbd2/transaction.c 			       journal->j_committing_transaction)) ||
journal          1482 fs/jbd2/transaction.c 			       journal->j_devname,
journal          1504 fs/jbd2/transaction.c 	spin_lock(&journal->j_list_lock);
journal          1506 fs/jbd2/transaction.c 	spin_unlock(&journal->j_list_lock);
journal          1534 fs/jbd2/transaction.c 	journal_t *journal;
journal          1542 fs/jbd2/transaction.c 	journal = transaction->t_journal;
journal          1599 fs/jbd2/transaction.c 		spin_lock(&journal->j_list_lock);
journal          1606 fs/jbd2/transaction.c 				spin_unlock(&journal->j_list_lock);
journal          1610 fs/jbd2/transaction.c 		spin_unlock(&journal->j_list_lock);
journal          1613 fs/jbd2/transaction.c 				 journal->j_committing_transaction));
journal          1627 fs/jbd2/transaction.c 			spin_lock(&journal->j_list_lock);
journal          1629 fs/jbd2/transaction.c 			spin_unlock(&journal->j_list_lock);
journal          1646 fs/jbd2/transaction.c 		spin_lock(&journal->j_list_lock);
journal          1649 fs/jbd2/transaction.c 			spin_unlock(&journal->j_list_lock);
journal          1659 fs/jbd2/transaction.c 			spin_unlock(&journal->j_list_lock);
journal          1671 fs/jbd2/transaction.c 		spin_unlock(&journal->j_list_lock);
journal          1708 fs/jbd2/transaction.c 	journal_t *journal;
journal          1729 fs/jbd2/transaction.c 	journal = transaction->t_journal;
journal          1745 fs/jbd2/transaction.c 	trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev,
journal          1783 fs/jbd2/transaction.c 	if (handle->h_sync && journal->j_last_sync_writer != pid &&
journal          1784 fs/jbd2/transaction.c 	    journal->j_max_batch_time) {
journal          1787 fs/jbd2/transaction.c 		journal->j_last_sync_writer = pid;
journal          1789 fs/jbd2/transaction.c 		read_lock(&journal->j_state_lock);
journal          1790 fs/jbd2/transaction.c 		commit_time = journal->j_average_commit_time;
journal          1791 fs/jbd2/transaction.c 		read_unlock(&journal->j_state_lock);
journal          1797 fs/jbd2/transaction.c 				    1000*journal->j_min_batch_time);
journal          1799 fs/jbd2/transaction.c 				    1000*journal->j_max_batch_time);
journal          1823 fs/jbd2/transaction.c 	     journal->j_max_transaction_buffers) ||
journal          1832 fs/jbd2/transaction.c 		jbd2_log_start_commit(journal, transaction->t_tid);
journal          1850 fs/jbd2/transaction.c 		wake_up(&journal->j_wait_updates);
journal          1851 fs/jbd2/transaction.c 		if (journal->j_barrier_count)
journal          1852 fs/jbd2/transaction.c 			wake_up(&journal->j_wait_transaction_locked);
journal          1855 fs/jbd2/transaction.c 	rwsem_release(&journal->j_trans_commit_map, 1, _THIS_IP_);
journal          1858 fs/jbd2/transaction.c 		err = jbd2_log_wait_commit(journal, tid);
journal          1991 fs/jbd2/transaction.c void jbd2_journal_unfile_buffer(journal_t *journal, struct journal_head *jh)
journal          1998 fs/jbd2/transaction.c 	spin_lock(&journal->j_list_lock);
journal          2000 fs/jbd2/transaction.c 	spin_unlock(&journal->j_list_lock);
journal          2011 fs/jbd2/transaction.c __journal_try_to_free_buffer(journal_t *journal, struct buffer_head *bh)
journal          2023 fs/jbd2/transaction.c 	spin_lock(&journal->j_list_lock);
journal          2029 fs/jbd2/transaction.c 	spin_unlock(&journal->j_list_lock);
journal          2072 fs/jbd2/transaction.c int jbd2_journal_try_to_free_buffers(journal_t *journal,
journal          2096 fs/jbd2/transaction.c 		__journal_try_to_free_buffer(journal, bh);
journal          2191 fs/jbd2/transaction.c static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh,
journal          2210 fs/jbd2/transaction.c 	write_lock(&journal->j_state_lock);
journal          2212 fs/jbd2/transaction.c 	spin_lock(&journal->j_list_lock);
journal          2262 fs/jbd2/transaction.c 		if (journal->j_running_transaction) {
journal          2268 fs/jbd2/transaction.c 					journal->j_running_transaction);
journal          2275 fs/jbd2/transaction.c 			if (journal->j_committing_transaction) {
journal          2278 fs/jbd2/transaction.c 					journal->j_committing_transaction);
journal          2288 fs/jbd2/transaction.c 	} else if (transaction == journal->j_committing_transaction) {
journal          2297 fs/jbd2/transaction.c 			spin_unlock(&journal->j_list_lock);
journal          2299 fs/jbd2/transaction.c 			write_unlock(&journal->j_state_lock);
journal          2310 fs/jbd2/transaction.c 		if (journal->j_running_transaction && buffer_jbddirty(bh))
journal          2311 fs/jbd2/transaction.c 			jh->b_next_transaction = journal->j_running_transaction;
journal          2314 fs/jbd2/transaction.c 		spin_unlock(&journal->j_list_lock);
journal          2316 fs/jbd2/transaction.c 		write_unlock(&journal->j_state_lock);
journal          2325 fs/jbd2/transaction.c 		J_ASSERT_JH(jh, transaction == journal->j_running_transaction);
journal          2342 fs/jbd2/transaction.c 	spin_unlock(&journal->j_list_lock);
journal          2344 fs/jbd2/transaction.c 	write_unlock(&journal->j_state_lock);
journal          2369 fs/jbd2/transaction.c int jbd2_journal_invalidatepage(journal_t *journal,
journal          2403 fs/jbd2/transaction.c 			ret = journal_unmap_buffer(journal, bh, partial_page);
journal          2559 fs/jbd2/transaction.c void jbd2_journal_refile_buffer(journal_t *journal, struct journal_head *jh)
journal          2566 fs/jbd2/transaction.c 	spin_lock(&journal->j_list_lock);
journal          2569 fs/jbd2/transaction.c 	spin_unlock(&journal->j_list_lock);
journal          2580 fs/jbd2/transaction.c 	journal_t *journal;
journal          2584 fs/jbd2/transaction.c 	journal = transaction->t_journal;
journal          2589 fs/jbd2/transaction.c 	spin_lock(&journal->j_list_lock);
journal          2617 fs/jbd2/transaction.c 					journal->j_committing_transaction);
journal          2626 fs/jbd2/transaction.c 	spin_unlock(&journal->j_list_lock);
journal          2666 fs/jbd2/transaction.c int jbd2_journal_begin_ordered_truncate(journal_t *journal,
journal          2679 fs/jbd2/transaction.c 	read_lock(&journal->j_state_lock);
journal          2680 fs/jbd2/transaction.c 	commit_trans = journal->j_committing_transaction;
journal          2681 fs/jbd2/transaction.c 	read_unlock(&journal->j_state_lock);
journal          2682 fs/jbd2/transaction.c 	spin_lock(&journal->j_list_lock);
journal          2684 fs/jbd2/transaction.c 	spin_unlock(&journal->j_list_lock);
journal          2689 fs/jbd2/transaction.c 			jbd2_journal_abort(journal, ret);
journal          5996 fs/ocfs2/alloc.c 	struct ocfs2_journal *journal = osb->journal;
journal          6023 fs/ocfs2/alloc.c 	jbd2_journal_lock_updates(journal->j_journal);
journal          6024 fs/ocfs2/alloc.c 	status = jbd2_journal_flush(journal->j_journal);
journal          6025 fs/ocfs2/alloc.c 	jbd2_journal_unlock_updates(journal->j_journal);
journal          6135 fs/ocfs2/alloc.c 	if (jbd2_journal_start_commit(osb->journal->j_journal, &target)) {
journal          6136 fs/ocfs2/alloc.c 		jbd2_log_wait_commit(osb->journal->j_journal, target);
journal           173 fs/ocfs2/file.c 	journal_t *journal = osb->journal->j_journal;
journal           192 fs/ocfs2/file.c 	if (journal->j_flags & JBD2_BARRIER &&
journal           193 fs/ocfs2/file.c 	    !jbd2_trans_will_send_data_barrier(journal, commit_tid))
journal           195 fs/ocfs2/file.c 	err = jbd2_complete_transaction(journal, commit_tid);
journal          2406 fs/ocfs2/file.c 			ret = jbd2_journal_force_commit(osb->journal->j_journal);
journal           130 fs/ocfs2/inode.c 	journal_t *journal = OCFS2_SB(sb)->journal->j_journal;
journal           177 fs/ocfs2/inode.c 	if (journal) {
journal           182 fs/ocfs2/inode.c 		read_lock(&journal->j_state_lock);
journal           183 fs/ocfs2/inode.c 		if (journal->j_running_transaction)
journal           184 fs/ocfs2/inode.c 			transaction = journal->j_running_transaction;
journal           186 fs/ocfs2/inode.c 			transaction = journal->j_committing_transaction;
journal           190 fs/ocfs2/inode.c 			tid = journal->j_commit_sequence;
journal           191 fs/ocfs2/inode.c 		read_unlock(&journal->j_state_lock);
journal          1210 fs/ocfs2/inode.c 	jbd2_journal_release_jbd_inode(osb->journal->j_journal,
journal           263 fs/ocfs2/ioctl.c 	oij.ij_journal_size = i_size_read(osb->journal->j_inode);
journal            63 fs/ocfs2/journal.c static void ocfs2_queue_recovery_completion(struct ocfs2_journal *journal,
journal           156 fs/ocfs2/journal.c 			ocfs2_queue_recovery_completion(osb->journal, i, NULL,
journal           298 fs/ocfs2/journal.c 	struct ocfs2_journal *journal = NULL;
journal           300 fs/ocfs2/journal.c 	journal = osb->journal;
journal           303 fs/ocfs2/journal.c 	down_write(&journal->j_trans_barrier);
journal           305 fs/ocfs2/journal.c 	flushed = atomic_read(&journal->j_num_trans);
journal           308 fs/ocfs2/journal.c 		up_write(&journal->j_trans_barrier);
journal           312 fs/ocfs2/journal.c 	jbd2_journal_lock_updates(journal->j_journal);
journal           313 fs/ocfs2/journal.c 	status = jbd2_journal_flush(journal->j_journal);
journal           314 fs/ocfs2/journal.c 	jbd2_journal_unlock_updates(journal->j_journal);
journal           316 fs/ocfs2/journal.c 		up_write(&journal->j_trans_barrier);
journal           321 fs/ocfs2/journal.c 	ocfs2_inc_trans_id(journal);
journal           323 fs/ocfs2/journal.c 	flushed = atomic_read(&journal->j_num_trans);
journal           324 fs/ocfs2/journal.c 	atomic_set(&journal->j_num_trans, 0);
journal           325 fs/ocfs2/journal.c 	up_write(&journal->j_trans_barrier);
journal           327 fs/ocfs2/journal.c 	trace_ocfs2_commit_cache_end(journal->j_trans_id, flushed);
journal           330 fs/ocfs2/journal.c 	wake_up(&journal->j_checkpointed);
journal           337 fs/ocfs2/journal.c 	journal_t *journal = osb->journal->j_journal;
journal           340 fs/ocfs2/journal.c 	BUG_ON(!osb || !osb->journal->j_journal);
journal           345 fs/ocfs2/journal.c 	BUG_ON(osb->journal->j_state == OCFS2_JOURNAL_FREE);
journal           350 fs/ocfs2/journal.c 		return jbd2_journal_start(journal, max_buffs);
journal           354 fs/ocfs2/journal.c 	down_read(&osb->journal->j_trans_barrier);
journal           356 fs/ocfs2/journal.c 	handle = jbd2_journal_start(journal, max_buffs);
journal           358 fs/ocfs2/journal.c 		up_read(&osb->journal->j_trans_barrier);
journal           363 fs/ocfs2/journal.c 		if (is_journal_aborted(journal)) {
journal           369 fs/ocfs2/journal.c 			atomic_inc(&(osb->journal->j_num_trans));
journal           379 fs/ocfs2/journal.c 	struct ocfs2_journal *journal = osb->journal;
journal           389 fs/ocfs2/journal.c 		up_read(&journal->j_trans_barrier);
journal           684 fs/ocfs2/journal.c 	ocfs2_set_ci_lock_trans(osb->journal, ci);
journal           783 fs/ocfs2/journal.c 			journal_t *journal = handle->h_transaction->t_journal;
journal           790 fs/ocfs2/journal.c 			jbd2_journal_abort(journal, status);
journal           800 fs/ocfs2/journal.c 	journal_t *journal = osb->journal->j_journal;
journal           806 fs/ocfs2/journal.c 	write_lock(&journal->j_state_lock);
journal           807 fs/ocfs2/journal.c 	journal->j_commit_interval = commit_interval;
journal           809 fs/ocfs2/journal.c 		journal->j_flags |= JBD2_BARRIER;
journal           811 fs/ocfs2/journal.c 		journal->j_flags &= ~JBD2_BARRIER;
journal           812 fs/ocfs2/journal.c 	write_unlock(&journal->j_state_lock);
journal           815 fs/ocfs2/journal.c int ocfs2_journal_init(struct ocfs2_journal *journal, int *dirty)
journal           825 fs/ocfs2/journal.c 	BUG_ON(!journal);
journal           827 fs/ocfs2/journal.c 	osb = journal->j_osb;
journal           885 fs/ocfs2/journal.c 	journal->j_journal = j_journal;
journal           886 fs/ocfs2/journal.c 	journal->j_inode = inode;
journal           887 fs/ocfs2/journal.c 	journal->j_bh = bh;
journal           891 fs/ocfs2/journal.c 	journal->j_state = OCFS2_JOURNAL_LOADED;
journal           923 fs/ocfs2/journal.c 	struct ocfs2_journal *journal = osb->journal;
journal           924 fs/ocfs2/journal.c 	struct buffer_head *bh = journal->j_bh;
journal           945 fs/ocfs2/journal.c 	status = ocfs2_write_block(osb, bh, INODE_CACHE(journal->j_inode));
journal           958 fs/ocfs2/journal.c 	struct ocfs2_journal *journal = NULL;
journal           965 fs/ocfs2/journal.c 	journal = osb->journal;
journal           966 fs/ocfs2/journal.c 	if (!journal)
journal           969 fs/ocfs2/journal.c 	inode = journal->j_inode;
journal           971 fs/ocfs2/journal.c 	if (journal->j_state != OCFS2_JOURNAL_LOADED)
journal           978 fs/ocfs2/journal.c 	num_running_trans = atomic_read(&(osb->journal->j_num_trans));
journal           985 fs/ocfs2/journal.c 	journal->j_state = OCFS2_JOURNAL_IN_SHUTDOWN;
journal           997 fs/ocfs2/journal.c 	BUG_ON(atomic_read(&(osb->journal->j_num_trans)) != 0);
journal          1000 fs/ocfs2/journal.c 		jbd2_journal_lock_updates(journal->j_journal);
journal          1001 fs/ocfs2/journal.c 		status = jbd2_journal_flush(journal->j_journal);
journal          1002 fs/ocfs2/journal.c 		jbd2_journal_unlock_updates(journal->j_journal);
journal          1008 fs/ocfs2/journal.c 	if (!jbd2_journal_destroy(journal->j_journal) && !status) {
journal          1017 fs/ocfs2/journal.c 	journal->j_journal = NULL;
journal          1024 fs/ocfs2/journal.c 	brelse(journal->j_bh);
journal          1025 fs/ocfs2/journal.c 	journal->j_bh = NULL;
journal          1027 fs/ocfs2/journal.c 	journal->j_state = OCFS2_JOURNAL_FREE;
journal          1035 fs/ocfs2/journal.c 				      journal_t *journal,
journal          1040 fs/ocfs2/journal.c 	olderr = jbd2_journal_errno(journal);
journal          1047 fs/ocfs2/journal.c 		jbd2_journal_ack_err(journal);
journal          1048 fs/ocfs2/journal.c 		jbd2_journal_clear_err(journal);
journal          1052 fs/ocfs2/journal.c int ocfs2_journal_load(struct ocfs2_journal *journal, int local, int replayed)
journal          1057 fs/ocfs2/journal.c 	BUG_ON(!journal);
journal          1059 fs/ocfs2/journal.c 	osb = journal->j_osb;
journal          1061 fs/ocfs2/journal.c 	status = jbd2_journal_load(journal->j_journal);
journal          1067 fs/ocfs2/journal.c 	ocfs2_clear_journal_error(osb->sb, journal->j_journal, osb->slot_num);
journal          1070 fs/ocfs2/journal.c 		jbd2_journal_lock_updates(journal->j_journal);
journal          1071 fs/ocfs2/journal.c 		status = jbd2_journal_flush(journal->j_journal);
journal          1072 fs/ocfs2/journal.c 		jbd2_journal_unlock_updates(journal->j_journal);
journal          1104 fs/ocfs2/journal.c int ocfs2_journal_wipe(struct ocfs2_journal *journal, int full)
journal          1108 fs/ocfs2/journal.c 	BUG_ON(!journal);
journal          1110 fs/ocfs2/journal.c 	status = jbd2_journal_wipe(journal->j_journal, full);
journal          1116 fs/ocfs2/journal.c 	status = ocfs2_journal_toggle_dirty(journal->j_osb, 0, 0);
journal          1220 fs/ocfs2/journal.c 	struct ocfs2_journal *journal =
journal          1222 fs/ocfs2/journal.c 	struct ocfs2_super *osb = journal->j_osb;
journal          1230 fs/ocfs2/journal.c 		(unsigned long long)OCFS2_I(journal->j_inode)->ip_blkno);
journal          1232 fs/ocfs2/journal.c 	spin_lock(&journal->j_lock);
journal          1233 fs/ocfs2/journal.c 	list_splice_init(&journal->j_la_cleanups, &tmp_la_list);
journal          1234 fs/ocfs2/journal.c 	spin_unlock(&journal->j_lock);
journal          1291 fs/ocfs2/journal.c static void ocfs2_queue_recovery_completion(struct ocfs2_journal *journal,
journal          1322 fs/ocfs2/journal.c 	spin_lock(&journal->j_lock);
journal          1323 fs/ocfs2/journal.c 	list_add_tail(&item->lri_list, &journal->j_la_cleanups);
journal          1324 fs/ocfs2/journal.c 	queue_work(journal->j_osb->ocfs2_wq, &journal->j_recovery_work);
journal          1325 fs/ocfs2/journal.c 	spin_unlock(&journal->j_lock);
journal          1332 fs/ocfs2/journal.c 	struct ocfs2_journal *journal = osb->journal;
journal          1339 fs/ocfs2/journal.c 	ocfs2_queue_recovery_completion(journal, osb->slot_num,
journal          1355 fs/ocfs2/journal.c 		ocfs2_queue_recovery_completion(osb->journal,
journal          1404 fs/ocfs2/journal.c 	ocfs2_queue_recovery_completion(osb->journal, osb->slot_num, NULL,
journal          1469 fs/ocfs2/journal.c 			ocfs2_queue_recovery_completion(osb->journal,
journal          1578 fs/ocfs2/journal.c 	journal_t *journal = NULL;
journal          1647 fs/ocfs2/journal.c 	journal = jbd2_journal_init_inode(inode);
journal          1648 fs/ocfs2/journal.c 	if (journal == NULL) {
journal          1654 fs/ocfs2/journal.c 	status = jbd2_journal_load(journal);
journal          1659 fs/ocfs2/journal.c 		jbd2_journal_destroy(journal);
journal          1663 fs/ocfs2/journal.c 	ocfs2_clear_journal_error(osb->sb, journal, slot_num);
journal          1666 fs/ocfs2/journal.c 	jbd2_journal_lock_updates(journal);
journal          1667 fs/ocfs2/journal.c 	status = jbd2_journal_flush(journal);
journal          1668 fs/ocfs2/journal.c 	jbd2_journal_unlock_updates(journal);
journal          1690 fs/ocfs2/journal.c 	jbd2_journal_destroy(journal);
journal          1763 fs/ocfs2/journal.c 	ocfs2_queue_recovery_completion(osb->journal, slot_num, la_copy,
journal          1952 fs/ocfs2/journal.c 		ocfs2_queue_recovery_completion(osb->journal, i, NULL, NULL,
journal          2294 fs/ocfs2/journal.c 	struct ocfs2_journal *journal = osb->journal;
journal          2301 fs/ocfs2/journal.c 		 atomic_read(&journal->j_num_trans) == 0)) {
journal          2304 fs/ocfs2/journal.c 					 atomic_read(&journal->j_num_trans)
journal          2323 fs/ocfs2/journal.c 		if (kthread_should_stop() && atomic_read(&journal->j_num_trans)){
journal          2327 fs/ocfs2/journal.c 			     atomic_read(&journal->j_num_trans));
journal            80 fs/ocfs2/journal.h static inline void ocfs2_set_ci_lock_trans(struct ocfs2_journal *journal,
journal            84 fs/ocfs2/journal.h 	ci->ci_last_trans = journal->j_trans_id;
journal            96 fs/ocfs2/journal.h 	struct ocfs2_journal *journal =
journal            97 fs/ocfs2/journal.h 		OCFS2_SB(ocfs2_metadata_cache_get_super(ci))->journal;
journal           100 fs/ocfs2/journal.h 	ret = time_after(journal->j_trans_id, ci->ci_last_trans);
journal           112 fs/ocfs2/journal.h 	struct ocfs2_journal *journal =
journal           113 fs/ocfs2/journal.h 		OCFS2_SB(ocfs2_metadata_cache_get_super(ci))->journal;
journal           116 fs/ocfs2/journal.h 	ret = !(time_after(journal->j_trans_id, ci->ci_created_trans));
journal           139 fs/ocfs2/journal.h 	ci->ci_created_trans = osb->journal->j_trans_id;
journal           172 fs/ocfs2/journal.h int    ocfs2_journal_init(struct ocfs2_journal *journal,
journal           175 fs/ocfs2/journal.h int    ocfs2_journal_wipe(struct ocfs2_journal *journal,
journal           177 fs/ocfs2/journal.h int    ocfs2_journal_load(struct ocfs2_journal *journal, int local,
journal           207 fs/ocfs2/journal.h 		wait_event(osb->journal->j_checkpointed,
journal           589 fs/ocfs2/journal.h 				OCFS2_SB(inode->i_sb)->journal->j_journal,
journal          1559 fs/ocfs2/namei.c 		if (!is_journal_aborted(osb->journal->j_journal)) {
journal          1571 fs/ocfs2/namei.c 		if (!is_journal_aborted(osb->journal->j_journal)) {
journal           353 fs/ocfs2/ocfs2.h 	struct ocfs2_journal *journal;
journal           288 fs/ocfs2/super.c 			"Journal", osb->journal->j_state,
journal           289 fs/ocfs2/super.c 			osb->journal->j_trans_id,
journal           290 fs/ocfs2/super.c 			atomic_read(&osb->journal->j_num_trans));
journal           412 fs/ocfs2/super.c 	if (jbd2_journal_start_commit(osb->journal->j_journal,
journal           415 fs/ocfs2/super.c 			jbd2_log_wait_commit(osb->journal->j_journal,
journal          1980 fs/ocfs2/super.c 	      jbd2_journal_check_used_features(osb->journal->j_journal, 0, 0,
journal          2001 fs/ocfs2/super.c 	struct ocfs2_journal *journal;
journal          2185 fs/ocfs2/super.c 	journal = kzalloc(sizeof(struct ocfs2_journal), GFP_KERNEL);
journal          2186 fs/ocfs2/super.c 	if (!journal) {
journal          2191 fs/ocfs2/super.c 	osb->journal = journal;
journal          2192 fs/ocfs2/super.c 	journal->j_osb = osb;
journal          2194 fs/ocfs2/super.c 	atomic_set(&journal->j_num_trans, 0);
journal          2195 fs/ocfs2/super.c 	init_rwsem(&journal->j_trans_barrier);
journal          2196 fs/ocfs2/super.c 	init_waitqueue_head(&journal->j_checkpointed);
journal          2197 fs/ocfs2/super.c 	spin_lock_init(&journal->j_lock);
journal          2198 fs/ocfs2/super.c 	journal->j_trans_id = (unsigned long) 1;
journal          2199 fs/ocfs2/super.c 	INIT_LIST_HEAD(&journal->j_la_cleanups);
journal          2200 fs/ocfs2/super.c 	INIT_WORK(&journal->j_recovery_work, ocfs2_complete_recovery);
journal          2201 fs/ocfs2/super.c 	journal->j_state = OCFS2_JOURNAL_FREE;
journal          2383 fs/ocfs2/super.c 	status = ocfs2_journal_init(osb->journal, &dirty);
journal          2399 fs/ocfs2/super.c 		status = ocfs2_journal_wipe(osb->journal, 0);
journal          2412 fs/ocfs2/super.c 	status = ocfs2_journal_load(osb->journal, local, dirty);
journal          2419 fs/ocfs2/super.c 		jbd2_journal_set_features(osb->journal->j_journal,
journal          2423 fs/ocfs2/super.c 		jbd2_journal_clear_features(osb->journal->j_journal,
journal          2497 fs/ocfs2/super.c 	kfree(osb->journal);
journal            96 fs/reiserfs/journal.c 			       struct reiserfs_journal *journal);
journal           117 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal           118 fs/reiserfs/journal.c 	memset(journal->j_hash_table, 0,
journal           159 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal           161 fs/reiserfs/journal.c 	struct list_head *entry = journal->j_bitmap_nodes.next;
journal           163 fs/reiserfs/journal.c 	journal->j_used_bitmap_nodes++;
journal           166 fs/reiserfs/journal.c 	if (entry != &journal->j_bitmap_nodes) {
journal           170 fs/reiserfs/journal.c 		journal->j_free_bitmap_nodes--;
journal           183 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal           184 fs/reiserfs/journal.c 	journal->j_used_bitmap_nodes--;
journal           185 fs/reiserfs/journal.c 	if (journal->j_free_bitmap_nodes > REISERFS_MAX_BITMAP_NODES) {
journal           189 fs/reiserfs/journal.c 		list_add(&bn->list, &journal->j_bitmap_nodes);
journal           190 fs/reiserfs/journal.c 		journal->j_free_bitmap_nodes++;
journal           197 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal           202 fs/reiserfs/journal.c 			list_add(&bn->list, &journal->j_bitmap_nodes);
journal           203 fs/reiserfs/journal.c 			journal->j_free_bitmap_nodes++;
journal           260 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal           261 fs/reiserfs/journal.c 	struct list_head *next = journal->j_bitmap_nodes.next;
journal           264 fs/reiserfs/journal.c 	while (next != &journal->j_bitmap_nodes) {
journal           269 fs/reiserfs/journal.c 		next = journal->j_bitmap_nodes.next;
journal           270 fs/reiserfs/journal.c 		journal->j_free_bitmap_nodes--;
journal           316 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal           320 fs/reiserfs/journal.c 		i = journal->j_list_bitmap_index;
journal           321 fs/reiserfs/journal.c 		journal->j_list_bitmap_index = (i + 1) % JOURNAL_NUM_BITMAPS;
journal           322 fs/reiserfs/journal.c 		jb = journal->j_list_bitmap + i;
journal           323 fs/reiserfs/journal.c 		if (journal->j_list_bitmap[i].journal_list) {
journal           325 fs/reiserfs/journal.c 					  journal->j_list_bitmap[i].
journal           327 fs/reiserfs/journal.c 			if (!journal->j_list_bitmap[i].journal_list) {
journal           372 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal           376 fs/reiserfs/journal.c 	if (journal->j_cnode_free <= 0) {
journal           379 fs/reiserfs/journal.c 	journal->j_cnode_used++;
journal           380 fs/reiserfs/journal.c 	journal->j_cnode_free--;
journal           381 fs/reiserfs/journal.c 	cn = journal->j_cnode_free_list;
journal           388 fs/reiserfs/journal.c 	journal->j_cnode_free_list = cn->next;
journal           399 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal           403 fs/reiserfs/journal.c 	journal->j_cnode_used--;
journal           404 fs/reiserfs/journal.c 	journal->j_cnode_free++;
journal           406 fs/reiserfs/journal.c 	cn->next = journal->j_cnode_free_list;
journal           407 fs/reiserfs/journal.c 	if (journal->j_cnode_free_list) {
journal           408 fs/reiserfs/journal.c 		journal->j_cnode_free_list->prev = cn;
journal           411 fs/reiserfs/journal.c 	journal->j_cnode_free_list = cn;
journal           465 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal           473 fs/reiserfs/journal.c 	PROC_INFO_INC(sb, journal.in_journal);
journal           482 fs/reiserfs/journal.c 			PROC_INFO_INC(sb, journal.in_journal_bitmap);
journal           483 fs/reiserfs/journal.c 			jb = journal->j_list_bitmap + i;
journal           503 fs/reiserfs/journal.c 		get_journal_hash_dev(sb, journal->j_list_hash_table, bl))) {
journal           508 fs/reiserfs/journal.c 	if ((cn = get_journal_hash_dev(sb, journal->j_hash_table, bl))) {
journal           513 fs/reiserfs/journal.c 	PROC_INFO_INC(sb, journal.in_journal_reusable);
journal           536 fs/reiserfs/journal.c 	PROC_INFO_INC(sb, journal.lock_journal);
journal           583 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal           584 fs/reiserfs/journal.c 	struct list_head *entry = &journal->j_journal_list;
journal           888 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal           903 fs/reiserfs/journal.c 		if (entry == &journal->j_journal_list ||
journal           941 fs/reiserfs/journal.c 			if (entry == &journal->j_journal_list)
journal           979 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal           995 fs/reiserfs/journal.c 	BUG_ON(trans_id == journal->j_trans_id);
journal          1034 fs/reiserfs/journal.c 		ret = write_ordered_buffers(&journal->j_dirty_buffers_lock,
journal          1035 fs/reiserfs/journal.c 					    journal, jl, &jl->j_bh_list);
journal          1048 fs/reiserfs/journal.c 	atomic_inc(&journal->j_async_throttle);
journal          1065 fs/reiserfs/journal.c 	atomic_dec(&journal->j_async_throttle);
journal          1107 fs/reiserfs/journal.c 	if (likely(!retval && !reiserfs_is_journal_aborted (journal))) {
journal          1132 fs/reiserfs/journal.c 	if (journal->j_last_commit_id != 0 &&
journal          1133 fs/reiserfs/journal.c 	    (jl->j_trans_id - journal->j_last_commit_id) != 1) {
journal          1135 fs/reiserfs/journal.c 				 journal->j_last_commit_id, jl->j_trans_id);
journal          1137 fs/reiserfs/journal.c 	journal->j_last_commit_id = jl->j_trans_id;
journal          1145 fs/reiserfs/journal.c 	retval = retval ? retval : journal->j_errno;
journal          1201 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          1218 fs/reiserfs/journal.c 			remove_journal_hash(sb, journal->j_list_hash_table,
journal          1241 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          1244 fs/reiserfs/journal.c 	if (reiserfs_is_journal_aborted(journal))
journal          1247 fs/reiserfs/journal.c 	if (trans_id >= journal->j_last_flush_trans_id) {
journal          1248 fs/reiserfs/journal.c 		if (buffer_locked((journal->j_header_bh))) {
journal          1250 fs/reiserfs/journal.c 			__wait_on_buffer(journal->j_header_bh);
journal          1252 fs/reiserfs/journal.c 			if (unlikely(!buffer_uptodate(journal->j_header_bh))) {
journal          1260 fs/reiserfs/journal.c 		journal->j_last_flush_trans_id = trans_id;
journal          1261 fs/reiserfs/journal.c 		journal->j_first_unflushed_offset = offset;
journal          1262 fs/reiserfs/journal.c 		jh = (struct reiserfs_journal_header *)(journal->j_header_bh->
journal          1266 fs/reiserfs/journal.c 		jh->j_mount_id = cpu_to_le32(journal->j_mount_id);
journal          1268 fs/reiserfs/journal.c 		set_buffer_dirty(journal->j_header_bh);
journal          1272 fs/reiserfs/journal.c 			__sync_dirty_buffer(journal->j_header_bh,
journal          1275 fs/reiserfs/journal.c 			sync_dirty_buffer(journal->j_header_bh);
journal          1278 fs/reiserfs/journal.c 		if (!buffer_uptodate(journal->j_header_bh)) {
journal          1303 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          1311 fs/reiserfs/journal.c 	entry = journal->j_journal_list.next;
journal          1313 fs/reiserfs/journal.c 	if (entry == &journal->j_journal_list)
journal          1330 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal          1333 fs/reiserfs/journal.c 		journal->j_num_work_lists--;
journal          1357 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal          1363 fs/reiserfs/journal.c 	if (atomic_read(&journal->j_wcount) != 0) {
journal          1365 fs/reiserfs/journal.c 				 atomic_read(&journal->j_wcount));
journal          1370 fs/reiserfs/journal.c 		reiserfs_mutex_lock_safe(&journal->j_flush_mutex, s);
journal          1371 fs/reiserfs/journal.c 	} else if (mutex_trylock(&journal->j_flush_mutex)) {
journal          1376 fs/reiserfs/journal.c 	if (j_len_saved > journal->j_trans_max) {
journal          1395 fs/reiserfs/journal.c 	    && !reiserfs_is_journal_aborted(journal))
journal          1408 fs/reiserfs/journal.c 	if (atomic_read(&journal->j_wcount) != 0) {
journal          1579 fs/reiserfs/journal.c 	err = journal->j_errno;
journal          1602 fs/reiserfs/journal.c 	journal->j_num_lists--;
journal          1605 fs/reiserfs/journal.c 	if (journal->j_last_flush_id != 0 &&
journal          1606 fs/reiserfs/journal.c 	    (jl->j_trans_id - journal->j_last_flush_id) != 1) {
journal          1608 fs/reiserfs/journal.c 				 journal->j_last_flush_id, jl->j_trans_id);
journal          1610 fs/reiserfs/journal.c 	journal->j_last_flush_id = jl->j_trans_id;
journal          1625 fs/reiserfs/journal.c 		mutex_unlock(&journal->j_flush_mutex);
journal          1728 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal          1731 fs/reiserfs/journal.c 	reiserfs_mutex_lock_safe(&journal->j_flush_mutex, s);
journal          1758 fs/reiserfs/journal.c 		if (entry == &journal->j_journal_list) {
journal          1772 fs/reiserfs/journal.c 	mutex_unlock(&journal->j_flush_mutex);
journal          1796 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal          1815 fs/reiserfs/journal.c 		if (tjl->j_list.next == &journal->j_journal_list)
journal          1883 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          1884 fs/reiserfs/journal.c 	kfree(journal->j_current_jl);
journal          1885 fs/reiserfs/journal.c 	journal->j_num_lists--;
journal          1887 fs/reiserfs/journal.c 	vfree(journal->j_cnode_free_orig);
journal          1888 fs/reiserfs/journal.c 	free_list_bitmaps(sb, journal->j_list_bitmap);
journal          1890 fs/reiserfs/journal.c 	if (journal->j_header_bh) {
journal          1891 fs/reiserfs/journal.c 		brelse(journal->j_header_bh);
journal          1897 fs/reiserfs/journal.c 	release_journal_dev(sb, journal);
journal          1898 fs/reiserfs/journal.c 	vfree(journal);
journal          1909 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          1934 fs/reiserfs/journal.c 	if (!error && reiserfs_is_journal_aborted(journal)) {
journal          2116 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          2299 fs/reiserfs/journal.c 	journal->j_start = cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb);
journal          2300 fs/reiserfs/journal.c 	journal->j_last_flush_trans_id = trans_id;
journal          2301 fs/reiserfs/journal.c 	journal->j_trans_id = trans_id + 1;
journal          2303 fs/reiserfs/journal.c 	if (journal->j_trans_id == 0)
journal          2304 fs/reiserfs/journal.c 		journal->j_trans_id = 10;
journal          2371 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          2388 fs/reiserfs/journal.c 		      journal->j_dev_bd);
journal          2396 fs/reiserfs/journal.c 	journal->j_header_bh = journal_bread(sb,
journal          2399 fs/reiserfs/journal.c 	if (!journal->j_header_bh) {
journal          2402 fs/reiserfs/journal.c 	jh = (struct reiserfs_journal_header *)(journal->j_header_bh->b_data);
journal          2449 fs/reiserfs/journal.c 		    reiserfs_breada(journal->j_dev_bd, cur_dblock,
journal          2515 fs/reiserfs/journal.c 		    SB_ONDISK_JOURNAL_1st_BLOCK(sb) + journal->j_start;
journal          2532 fs/reiserfs/journal.c 		journal->j_start = le32_to_cpu(jh->j_first_unflushed_offset);
journal          2533 fs/reiserfs/journal.c 		journal->j_trans_id =
journal          2536 fs/reiserfs/journal.c 		if (journal->j_trans_id == 0)
journal          2537 fs/reiserfs/journal.c 			journal->j_trans_id = 10;
journal          2538 fs/reiserfs/journal.c 		journal->j_last_flush_trans_id =
journal          2540 fs/reiserfs/journal.c 		journal->j_mount_id = le32_to_cpu(jh->j_mount_id) + 1;
journal          2542 fs/reiserfs/journal.c 		journal->j_mount_id = newest_mount_id + 1;
journal          2545 fs/reiserfs/journal.c 		       "newest_mount_id to %lu", journal->j_mount_id);
journal          2546 fs/reiserfs/journal.c 	journal->j_first_unflushed_offset = journal->j_start;
journal          2555 fs/reiserfs/journal.c 	    _update_journal_header_block(sb, journal->j_start,
journal          2556 fs/reiserfs/journal.c 					 journal->j_last_flush_trans_id)) {
journal          2589 fs/reiserfs/journal.c 			       struct reiserfs_journal *journal)
journal          2591 fs/reiserfs/journal.c 	if (journal->j_dev_bd != NULL) {
journal          2592 fs/reiserfs/journal.c 		blkdev_put(journal->j_dev_bd, journal->j_dev_mode);
journal          2593 fs/reiserfs/journal.c 		journal->j_dev_bd = NULL;
journal          2598 fs/reiserfs/journal.c 			    struct reiserfs_journal *journal,
journal          2608 fs/reiserfs/journal.c 	journal->j_dev_bd = NULL;
journal          2619 fs/reiserfs/journal.c 		journal->j_dev_bd = blkdev_get_by_dev(jdev, blkdev_mode,
journal          2620 fs/reiserfs/journal.c 						      journal);
journal          2621 fs/reiserfs/journal.c 		journal->j_dev_mode = blkdev_mode;
journal          2622 fs/reiserfs/journal.c 		if (IS_ERR(journal->j_dev_bd)) {
journal          2623 fs/reiserfs/journal.c 			result = PTR_ERR(journal->j_dev_bd);
journal          2624 fs/reiserfs/journal.c 			journal->j_dev_bd = NULL;
journal          2630 fs/reiserfs/journal.c 			set_blocksize(journal->j_dev_bd, super->s_blocksize);
journal          2635 fs/reiserfs/journal.c 	journal->j_dev_mode = blkdev_mode;
journal          2636 fs/reiserfs/journal.c 	journal->j_dev_bd = blkdev_get_by_path(jdev_name, blkdev_mode, journal);
journal          2637 fs/reiserfs/journal.c 	if (IS_ERR(journal->j_dev_bd)) {
journal          2638 fs/reiserfs/journal.c 		result = PTR_ERR(journal->j_dev_bd);
journal          2639 fs/reiserfs/journal.c 		journal->j_dev_bd = NULL;
journal          2646 fs/reiserfs/journal.c 	set_blocksize(journal->j_dev_bd, super->s_blocksize);
journal          2649 fs/reiserfs/journal.c 		      journal->j_dev_bd);
journal          2668 fs/reiserfs/journal.c 				     struct reiserfs_journal *journal)
journal          2670 fs/reiserfs/journal.c         if (journal->j_trans_max) {
journal          2676 fs/reiserfs/journal.c 		if (journal->j_trans_max > JOURNAL_TRANS_MAX_DEFAULT / ratio ||
journal          2677 fs/reiserfs/journal.c 		    journal->j_trans_max < JOURNAL_TRANS_MIN_DEFAULT / ratio ||
journal          2678 fs/reiserfs/journal.c 		    SB_ONDISK_JOURNAL_SIZE(sb) / journal->j_trans_max <
journal          2682 fs/reiserfs/journal.c 					 "FSCK?", journal->j_trans_max);
journal          2685 fs/reiserfs/journal.c 		if (journal->j_max_batch != (journal->j_trans_max) *
journal          2689 fs/reiserfs/journal.c 					 "FSCK?", journal->j_max_batch);
journal          2704 fs/reiserfs/journal.c 		journal->j_trans_max = JOURNAL_TRANS_MAX_DEFAULT;
journal          2705 fs/reiserfs/journal.c 		journal->j_max_batch = JOURNAL_MAX_BATCH_DEFAULT;
journal          2706 fs/reiserfs/journal.c 		journal->j_max_commit_age = JOURNAL_MAX_COMMIT_AGE;
journal          2719 fs/reiserfs/journal.c 	struct reiserfs_journal *journal;
journal          2723 fs/reiserfs/journal.c 	journal = SB_JOURNAL(sb) = vzalloc(sizeof(struct reiserfs_journal));
journal          2724 fs/reiserfs/journal.c 	if (!journal) {
journal          2729 fs/reiserfs/journal.c 	INIT_LIST_HEAD(&journal->j_bitmap_nodes);
journal          2730 fs/reiserfs/journal.c 	INIT_LIST_HEAD(&journal->j_prealloc_list);
journal          2731 fs/reiserfs/journal.c 	INIT_LIST_HEAD(&journal->j_working_list);
journal          2732 fs/reiserfs/journal.c 	INIT_LIST_HEAD(&journal->j_journal_list);
journal          2733 fs/reiserfs/journal.c 	journal->j_persistent_trans = 0;
journal          2734 fs/reiserfs/journal.c 	if (reiserfs_allocate_list_bitmaps(sb, journal->j_list_bitmap,
journal          2766 fs/reiserfs/journal.c 	if (journal_init_dev(sb, journal, j_dev_name) != 0) {
journal          2793 fs/reiserfs/journal.c 				 journal->j_dev_bd,
journal          2799 fs/reiserfs/journal.c 	journal->j_trans_max = le32_to_cpu(jh->jh_journal.jp_journal_trans_max);
journal          2800 fs/reiserfs/journal.c 	journal->j_max_batch = le32_to_cpu(jh->jh_journal.jp_journal_max_batch);
journal          2801 fs/reiserfs/journal.c 	journal->j_max_commit_age =
journal          2803 fs/reiserfs/journal.c 	journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
journal          2805 fs/reiserfs/journal.c 	if (check_advise_trans_params(sb, journal) != 0)
journal          2807 fs/reiserfs/journal.c 	journal->j_default_max_commit_age = journal->j_max_commit_age;
journal          2810 fs/reiserfs/journal.c 		journal->j_max_commit_age = commit_max_age;
journal          2811 fs/reiserfs/journal.c 		journal->j_max_trans_age = commit_max_age;
journal          2817 fs/reiserfs/journal.c 		      journal->j_dev_bd,
journal          2820 fs/reiserfs/journal.c 		      journal->j_trans_max,
journal          2821 fs/reiserfs/journal.c 		      journal->j_max_batch,
journal          2822 fs/reiserfs/journal.c 		      journal->j_max_commit_age, journal->j_max_trans_age);
journal          2826 fs/reiserfs/journal.c 	journal->j_list_bitmap_index = 0;
journal          2829 fs/reiserfs/journal.c 	memset(journal->j_list_hash_table, 0,
journal          2832 fs/reiserfs/journal.c 	INIT_LIST_HEAD(&journal->j_dirty_buffers);
journal          2833 fs/reiserfs/journal.c 	spin_lock_init(&journal->j_dirty_buffers_lock);
journal          2835 fs/reiserfs/journal.c 	journal->j_start = 0;
journal          2836 fs/reiserfs/journal.c 	journal->j_len = 0;
journal          2837 fs/reiserfs/journal.c 	journal->j_len_alloc = 0;
journal          2838 fs/reiserfs/journal.c 	atomic_set(&journal->j_wcount, 0);
journal          2839 fs/reiserfs/journal.c 	atomic_set(&journal->j_async_throttle, 0);
journal          2840 fs/reiserfs/journal.c 	journal->j_bcount = 0;
journal          2841 fs/reiserfs/journal.c 	journal->j_trans_start_time = 0;
journal          2842 fs/reiserfs/journal.c 	journal->j_last = NULL;
journal          2843 fs/reiserfs/journal.c 	journal->j_first = NULL;
journal          2844 fs/reiserfs/journal.c 	init_waitqueue_head(&journal->j_join_wait);
journal          2845 fs/reiserfs/journal.c 	mutex_init(&journal->j_mutex);
journal          2846 fs/reiserfs/journal.c 	mutex_init(&journal->j_flush_mutex);
journal          2848 fs/reiserfs/journal.c 	journal->j_trans_id = 10;
journal          2849 fs/reiserfs/journal.c 	journal->j_mount_id = 10;
journal          2850 fs/reiserfs/journal.c 	journal->j_state = 0;
journal          2851 fs/reiserfs/journal.c 	atomic_set(&journal->j_jlock, 0);
journal          2852 fs/reiserfs/journal.c 	journal->j_cnode_free_list = allocate_cnodes(num_cnodes);
journal          2853 fs/reiserfs/journal.c 	journal->j_cnode_free_orig = journal->j_cnode_free_list;
journal          2854 fs/reiserfs/journal.c 	journal->j_cnode_free = journal->j_cnode_free_list ? num_cnodes : 0;
journal          2855 fs/reiserfs/journal.c 	journal->j_cnode_used = 0;
journal          2856 fs/reiserfs/journal.c 	journal->j_must_wait = 0;
journal          2858 fs/reiserfs/journal.c 	if (journal->j_cnode_free == 0) {
journal          2868 fs/reiserfs/journal.c 	jl = journal->j_current_jl;
journal          2891 fs/reiserfs/journal.c 	INIT_DELAYED_WORK(&journal->j_work, flush_async_commits);
journal          2892 fs/reiserfs/journal.c 	journal->j_work_sb = sb;
journal          2907 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(th->t_super);
journal          2913 fs/reiserfs/journal.c 	if (journal->j_must_wait > 0 ||
journal          2914 fs/reiserfs/journal.c 	    (journal->j_len_alloc + new_alloc) >= journal->j_max_batch ||
journal          2915 fs/reiserfs/journal.c 	    atomic_read(&journal->j_jlock) ||
journal          2916 fs/reiserfs/journal.c 	    (now - journal->j_trans_start_time) > journal->j_max_trans_age ||
journal          2917 fs/reiserfs/journal.c 	    journal->j_cnode_free < (journal->j_trans_max * 3)) {
journal          2921 fs/reiserfs/journal.c 	journal->j_len_alloc += new_alloc;
journal          2929 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(th->t_super);
journal          2931 fs/reiserfs/journal.c 	journal->j_must_wait = 1;
journal          2932 fs/reiserfs/journal.c 	set_bit(J_WRITERS_BLOCKED, &journal->j_state);
journal          2939 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal          2940 fs/reiserfs/journal.c 	clear_bit(J_WRITERS_BLOCKED, &journal->j_state);
journal          2941 fs/reiserfs/journal.c 	wake_up(&journal->j_join_wait);
journal          2947 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal          2948 fs/reiserfs/journal.c 	wait_event(journal->j_join_wait,
journal          2949 fs/reiserfs/journal.c 		   !test_bit(J_WRITERS_BLOCKED, &journal->j_state));
journal          2955 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal          2956 fs/reiserfs/journal.c 	set_bit(J_WRITERS_QUEUED, &journal->j_state);
journal          2963 fs/reiserfs/journal.c 	add_wait_queue(&journal->j_join_wait, &wait);
journal          2965 fs/reiserfs/journal.c 	if (test_bit(J_WRITERS_QUEUED, &journal->j_state)) {
journal          2971 fs/reiserfs/journal.c 	remove_wait_queue(&journal->j_join_wait, &wait);
journal          2976 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal          2977 fs/reiserfs/journal.c 	if (test_and_clear_bit(J_WRITERS_QUEUED, &journal->j_state))
journal          2978 fs/reiserfs/journal.c 		wake_up(&journal->j_join_wait);
journal          2983 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          2984 fs/reiserfs/journal.c 	unsigned long bcount = journal->j_bcount;
journal          2992 fs/reiserfs/journal.c 		journal->j_current_jl->j_state |= LIST_COMMIT_PENDING;
journal          2993 fs/reiserfs/journal.c 		while ((atomic_read(&journal->j_wcount) > 0 ||
journal          2994 fs/reiserfs/journal.c 			atomic_read(&journal->j_jlock)) &&
journal          2995 fs/reiserfs/journal.c 		       journal->j_trans_id == trans_id) {
journal          2998 fs/reiserfs/journal.c 		if (journal->j_trans_id != trans_id)
journal          3000 fs/reiserfs/journal.c 		if (bcount == journal->j_bcount)
journal          3002 fs/reiserfs/journal.c 		bcount = journal->j_bcount;
journal          3019 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          3026 fs/reiserfs/journal.c 	BUG_ON(nblocks > journal->j_trans_max);
journal          3028 fs/reiserfs/journal.c 	PROC_INFO_INC(sb, journal.journal_being);
journal          3035 fs/reiserfs/journal.c 	if (join != JBEGIN_ABORT && reiserfs_is_journal_aborted(journal)) {
journal          3037 fs/reiserfs/journal.c 		retval = journal->j_errno;
journal          3040 fs/reiserfs/journal.c 	journal->j_bcount++;
journal          3042 fs/reiserfs/journal.c 	if (test_bit(J_WRITERS_BLOCKED, &journal->j_state)) {
journal          3047 fs/reiserfs/journal.c 		PROC_INFO_INC(sb, journal.journal_relock_writers);
journal          3059 fs/reiserfs/journal.c 	if ((!join && journal->j_must_wait > 0) ||
journal          3061 fs/reiserfs/journal.c 	     && (journal->j_len_alloc + nblocks + 2) >= journal->j_max_batch)
journal          3062 fs/reiserfs/journal.c 	    || (!join && atomic_read(&journal->j_wcount) > 0
journal          3063 fs/reiserfs/journal.c 		&& journal->j_trans_start_time > 0
journal          3064 fs/reiserfs/journal.c 		&& (now - journal->j_trans_start_time) >
journal          3065 fs/reiserfs/journal.c 		journal->j_max_trans_age) || (!join
journal          3066 fs/reiserfs/journal.c 					      && atomic_read(&journal->j_jlock))
journal          3067 fs/reiserfs/journal.c 	    || (!join && journal->j_cnode_free < (journal->j_trans_max * 3))) {
journal          3069 fs/reiserfs/journal.c 		old_trans_id = journal->j_trans_id;
journal          3073 fs/reiserfs/journal.c 		if (!join && (journal->j_len_alloc + nblocks + 2) >=
journal          3074 fs/reiserfs/journal.c 		    journal->j_max_batch &&
journal          3075 fs/reiserfs/journal.c 		    ((journal->j_len + nblocks + 2) * 100) <
journal          3076 fs/reiserfs/journal.c 		    (journal->j_len_alloc * 75)) {
journal          3077 fs/reiserfs/journal.c 			if (atomic_read(&journal->j_wcount) > 10) {
journal          3087 fs/reiserfs/journal.c 		if (atomic_read(&journal->j_jlock)) {
journal          3088 fs/reiserfs/journal.c 			while (journal->j_trans_id == old_trans_id &&
journal          3089 fs/reiserfs/journal.c 			       atomic_read(&journal->j_jlock)) {
journal          3099 fs/reiserfs/journal.c 		if (old_trans_id != journal->j_trans_id) {
journal          3108 fs/reiserfs/journal.c 		PROC_INFO_INC(sb, journal.journal_relock_wcount);
journal          3112 fs/reiserfs/journal.c 	if (journal->j_trans_start_time == 0) {
journal          3113 fs/reiserfs/journal.c 		journal->j_trans_start_time = ktime_get_seconds();
journal          3115 fs/reiserfs/journal.c 	atomic_inc(&journal->j_wcount);
journal          3116 fs/reiserfs/journal.c 	journal->j_len_alloc += nblocks;
journal          3119 fs/reiserfs/journal.c 	th->t_trans_id = journal->j_trans_id;
journal          3271 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          3277 fs/reiserfs/journal.c 	PROC_INFO_INC(sb, journal.mark_dirty);
journal          3278 fs/reiserfs/journal.c 	if (th->t_trans_id != journal->j_trans_id) {
journal          3281 fs/reiserfs/journal.c 			       th->t_trans_id, journal->j_trans_id);
journal          3288 fs/reiserfs/journal.c 		PROC_INFO_INC(sb, journal.mark_dirty_already);
journal          3308 fs/reiserfs/journal.c 	if (atomic_read(&journal->j_wcount) <= 0) {
journal          3311 fs/reiserfs/journal.c 				 atomic_read(&journal->j_wcount));
journal          3319 fs/reiserfs/journal.c 	if (journal->j_len >= journal->j_trans_max) {
journal          3322 fs/reiserfs/journal.c 			       journal->j_len);
journal          3327 fs/reiserfs/journal.c 		PROC_INFO_INC(sb, journal.mark_dirty_notjournal);
journal          3331 fs/reiserfs/journal.c 	if (journal->j_len > journal->j_len_alloc) {
journal          3332 fs/reiserfs/journal.c 		journal->j_len_alloc = journal->j_len + JOURNAL_PER_BALANCE_CNT;
journal          3346 fs/reiserfs/journal.c 			journal->j_len_alloc += JOURNAL_PER_BALANCE_CNT;
journal          3349 fs/reiserfs/journal.c 		journal->j_len++;
journal          3355 fs/reiserfs/journal.c 		insert_journal_hash(journal->j_hash_table, cn);
journal          3361 fs/reiserfs/journal.c 	cn->prev = journal->j_last;
journal          3363 fs/reiserfs/journal.c 	if (journal->j_last) {
journal          3364 fs/reiserfs/journal.c 		journal->j_last->next = cn;
journal          3365 fs/reiserfs/journal.c 		journal->j_last = cn;
journal          3367 fs/reiserfs/journal.c 		journal->j_first = cn;
journal          3368 fs/reiserfs/journal.c 		journal->j_last = cn;
journal          3420 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          3423 fs/reiserfs/journal.c 	cn = get_journal_hash_dev(sb, journal->j_hash_table, blocknr);
journal          3434 fs/reiserfs/journal.c 	if (cn == journal->j_first) {
journal          3435 fs/reiserfs/journal.c 		journal->j_first = cn->next;
journal          3437 fs/reiserfs/journal.c 	if (cn == journal->j_last) {
journal          3438 fs/reiserfs/journal.c 		journal->j_last = cn->prev;
journal          3440 fs/reiserfs/journal.c 	remove_journal_hash(sb, journal->j_hash_table, NULL,
journal          3455 fs/reiserfs/journal.c 	journal->j_len--;
journal          3456 fs/reiserfs/journal.c 	journal->j_len_alloc--;
journal          3514 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          3519 fs/reiserfs/journal.c 	if (journal->j_len == 0) {
journal          3530 fs/reiserfs/journal.c 	struct reiserfs_journal *journal =
journal          3532 fs/reiserfs/journal.c 	struct super_block *sb = journal->j_work_sb;
journal          3537 fs/reiserfs/journal.c 	if (!list_empty(&journal->j_journal_list)) {
journal          3539 fs/reiserfs/journal.c 		entry = journal->j_journal_list.prev;
journal          3554 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          3561 fs/reiserfs/journal.c 	if (list_empty(&journal->j_journal_list))
journal          3568 fs/reiserfs/journal.c 	if (atomic_read(&journal->j_wcount) <= 0 &&
journal          3569 fs/reiserfs/journal.c 	    journal->j_trans_start_time > 0 &&
journal          3570 fs/reiserfs/journal.c 	    journal->j_len > 0 &&
journal          3571 fs/reiserfs/journal.c 	    (now - journal->j_trans_start_time) > journal->j_max_trans_age) {
journal          3612 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          3616 fs/reiserfs/journal.c 	if (th->t_trans_id != journal->j_trans_id) {
journal          3619 fs/reiserfs/journal.c 			       th->t_trans_id, journal->j_trans_id);
journal          3622 fs/reiserfs/journal.c 	journal->j_len_alloc -= (th->t_blocks_allocated - th->t_blocks_logged);
journal          3624 fs/reiserfs/journal.c 	if (atomic_read(&journal->j_wcount) > 0)
journal          3625 fs/reiserfs/journal.c 		atomic_dec(&journal->j_wcount);
journal          3633 fs/reiserfs/journal.c 	BUG_ON(journal->j_len == 0);
journal          3643 fs/reiserfs/journal.c 	if (atomic_read(&journal->j_wcount) > 0) {
journal          3647 fs/reiserfs/journal.c 			jl = journal->j_current_jl;
journal          3651 fs/reiserfs/journal.c 			atomic_set(&journal->j_jlock, 1);
journal          3653 fs/reiserfs/journal.c 				journal->j_next_full_flush = 1;
journal          3661 fs/reiserfs/journal.c 			while (journal->j_trans_id == trans_id) {
journal          3662 fs/reiserfs/journal.c 				if (atomic_read(&journal->j_jlock)) {
journal          3666 fs/reiserfs/journal.c 					if (journal->j_trans_id == trans_id) {
journal          3667 fs/reiserfs/journal.c 						atomic_set(&journal->j_jlock,
journal          3673 fs/reiserfs/journal.c 			BUG_ON(journal->j_trans_id == trans_id);
journal          3688 fs/reiserfs/journal.c 	if ((now - journal->j_trans_start_time) > journal->j_max_trans_age) {
journal          3690 fs/reiserfs/journal.c 		journal->j_next_async_flush = 1;
journal          3694 fs/reiserfs/journal.c 	if (!(journal->j_must_wait > 0) && !(atomic_read(&journal->j_jlock))
journal          3695 fs/reiserfs/journal.c 	    && !flush && !commit_now && (journal->j_len < journal->j_max_batch)
journal          3696 fs/reiserfs/journal.c 	    && journal->j_len_alloc < journal->j_max_batch
journal          3697 fs/reiserfs/journal.c 	    && journal->j_cnode_free > (journal->j_trans_max * 3)) {
journal          3698 fs/reiserfs/journal.c 		journal->j_bcount++;
journal          3703 fs/reiserfs/journal.c 	if (journal->j_start > SB_ONDISK_JOURNAL_SIZE(sb)) {
journal          3706 fs/reiserfs/journal.c 			       journal->j_start);
journal          3731 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          3738 fs/reiserfs/journal.c 	cn = get_journal_hash_dev(sb, journal->j_hash_table, blocknr);
journal          3754 fs/reiserfs/journal.c 		jb = journal->j_current_jl->j_list_bitmap;
journal          3773 fs/reiserfs/journal.c 		cn = get_journal_hash_dev(sb, journal->j_list_hash_table,
journal          3821 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(inode->i_sb);
journal          3822 fs/reiserfs/journal.c 	REISERFS_I(inode)->i_jl = journal->j_current_jl;
journal          3823 fs/reiserfs/journal.c 	REISERFS_I(inode)->i_trans_id = journal->j_trans_id;
journal          3835 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          3842 fs/reiserfs/journal.c 	if (id == journal->j_trans_id) {
journal          3843 fs/reiserfs/journal.c 		jl = journal->j_current_jl;
journal          3849 fs/reiserfs/journal.c 		if (journal->j_trans_id != id) {
journal          3858 fs/reiserfs/journal.c 		if (journal->j_trans_id != id) {
journal          3886 fs/reiserfs/journal.c 			if (journal->j_errno)
journal          3887 fs/reiserfs/journal.c 				ret = journal->j_errno;
journal          3915 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          3916 fs/reiserfs/journal.c 	PROC_INFO_INC(sb, journal.restore_prepared);
journal          3925 fs/reiserfs/journal.c 					  journal->j_list_hash_table,
journal          3946 fs/reiserfs/journal.c 	PROC_INFO_INC(sb, journal.prepare);
journal          3975 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          4008 fs/reiserfs/journal.c 	if (journal->j_len == 0) {
journal          4015 fs/reiserfs/journal.c 	if (journal->j_next_full_flush) {
journal          4019 fs/reiserfs/journal.c 	if (journal->j_next_async_flush) {
journal          4037 fs/reiserfs/journal.c 	if (journal->j_next_full_flush) {
journal          4045 fs/reiserfs/journal.c 	if (journal->j_must_wait > 0) {
journal          4067 fs/reiserfs/journal.c 			   journal->j_start);
journal          4072 fs/reiserfs/journal.c 	set_desc_trans_id(desc, journal->j_trans_id);
journal          4079 fs/reiserfs/journal.c 			      ((journal->j_start + journal->j_len +
journal          4083 fs/reiserfs/journal.c 	set_commit_trans_id(commit, journal->j_trans_id);
journal          4087 fs/reiserfs/journal.c 	jl = journal->j_current_jl;
journal          4101 fs/reiserfs/journal.c 	jl->j_trans_id = journal->j_trans_id;
journal          4102 fs/reiserfs/journal.c 	jl->j_timestamp = journal->j_trans_start_time;
journal          4104 fs/reiserfs/journal.c 	jl->j_start = journal->j_start;
journal          4105 fs/reiserfs/journal.c 	jl->j_len = journal->j_len;
journal          4106 fs/reiserfs/journal.c 	atomic_set(&jl->j_nonzerolen, journal->j_len);
journal          4107 fs/reiserfs/journal.c 	atomic_set(&jl->j_commit_left, journal->j_len + 2);
journal          4116 fs/reiserfs/journal.c 	for (i = 0, cn = journal->j_first; cn; cn = cn->next, i++) {
journal          4148 fs/reiserfs/journal.c 			insert_journal_hash(journal->j_list_hash_table, jl_cn);
journal          4160 fs/reiserfs/journal.c 	set_desc_trans_len(desc, journal->j_len);
journal          4161 fs/reiserfs/journal.c 	set_desc_mount_id(desc, journal->j_mount_id);
journal          4162 fs/reiserfs/journal.c 	set_desc_trans_id(desc, journal->j_trans_id);
journal          4163 fs/reiserfs/journal.c 	set_commit_trans_len(commit, journal->j_len);
journal          4169 fs/reiserfs/journal.c 	BUG_ON(journal->j_len == 0);
journal          4182 fs/reiserfs/journal.c 	cur_write_start = journal->j_start;
journal          4183 fs/reiserfs/journal.c 	cn = journal->j_first;
journal          4231 fs/reiserfs/journal.c 	journal->j_current_jl = alloc_journal_list(sb);
journal          4234 fs/reiserfs/journal.c 	list_add_tail(&jl->j_list, &journal->j_journal_list);
journal          4235 fs/reiserfs/journal.c 	list_add_tail(&jl->j_working_list, &journal->j_working_list);
journal          4236 fs/reiserfs/journal.c 	journal->j_num_work_lists++;
journal          4239 fs/reiserfs/journal.c 	journal->j_start =
journal          4240 fs/reiserfs/journal.c 	    (journal->j_start + journal->j_len +
journal          4242 fs/reiserfs/journal.c 	atomic_set(&journal->j_wcount, 0);
journal          4243 fs/reiserfs/journal.c 	journal->j_bcount = 0;
journal          4244 fs/reiserfs/journal.c 	journal->j_last = NULL;
journal          4245 fs/reiserfs/journal.c 	journal->j_first = NULL;
journal          4246 fs/reiserfs/journal.c 	journal->j_len = 0;
journal          4247 fs/reiserfs/journal.c 	journal->j_trans_start_time = 0;
journal          4249 fs/reiserfs/journal.c 	if (++journal->j_trans_id == 0)
journal          4250 fs/reiserfs/journal.c 		journal->j_trans_id = 10;
journal          4251 fs/reiserfs/journal.c 	journal->j_current_jl->j_trans_id = journal->j_trans_id;
journal          4252 fs/reiserfs/journal.c 	journal->j_must_wait = 0;
journal          4253 fs/reiserfs/journal.c 	journal->j_len_alloc = 0;
journal          4254 fs/reiserfs/journal.c 	journal->j_next_full_flush = 0;
journal          4255 fs/reiserfs/journal.c 	journal->j_next_async_flush = 0;
journal          4273 fs/reiserfs/journal.c 		write_ordered_buffers(&journal->j_dirty_buffers_lock,
journal          4274 fs/reiserfs/journal.c 				      journal, jl, &jl->j_tail_bh_list);
journal          4298 fs/reiserfs/journal.c 					   &journal->j_work, HZ / 10);
journal          4307 fs/reiserfs/journal.c 	list_for_each_safe(entry, safe, &journal->j_journal_list) {
journal          4309 fs/reiserfs/journal.c 		if (journal->j_start <= temp_jl->j_start) {
journal          4310 fs/reiserfs/journal.c 			if ((journal->j_start + journal->j_trans_max + 1) >=
journal          4314 fs/reiserfs/journal.c 			} else if ((journal->j_start +
journal          4315 fs/reiserfs/journal.c 				    journal->j_trans_max + 1) <
journal          4325 fs/reiserfs/journal.c 		} else if ((journal->j_start +
journal          4326 fs/reiserfs/journal.c 			    journal->j_trans_max + 1) >
journal          4328 fs/reiserfs/journal.c 			if (((journal->j_start + journal->j_trans_max + 1) %
journal          4345 fs/reiserfs/journal.c 	journal->j_current_jl->j_list_bitmap =
journal          4346 fs/reiserfs/journal.c 	    get_list_bitmap(sb, journal->j_current_jl);
journal          4348 fs/reiserfs/journal.c 	if (!(journal->j_current_jl->j_list_bitmap)) {
journal          4353 fs/reiserfs/journal.c 	atomic_set(&journal->j_jlock, 0);
journal          4356 fs/reiserfs/journal.c 	clear_bit(J_WRITERS_QUEUED, &journal->j_state);
journal          4357 fs/reiserfs/journal.c 	wake_up(&journal->j_join_wait);
journal          4374 fs/reiserfs/journal.c 	return journal->j_errno;
journal          4380 fs/reiserfs/journal.c 	struct reiserfs_journal *journal = SB_JOURNAL(sb);
journal          4381 fs/reiserfs/journal.c 	if (test_bit(J_ABORTED, &journal->j_state))
journal          4384 fs/reiserfs/journal.c 	if (!journal->j_errno)
journal          4385 fs/reiserfs/journal.c 		journal->j_errno = errno;
journal          4388 fs/reiserfs/journal.c 	set_bit(J_ABORTED, &journal->j_state);
journal            53 fs/reiserfs/procfs.c #define SFPJ( x ) SFP( journal.x )
journal           507 fs/reiserfs/reiserfs.h 	} journal;
journal           760 fs/reiserfs/reiserfs.h #define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal)))
journal           762 fs/reiserfs/reiserfs.h 						*journal)
journal           764 fs/reiserfs/reiserfs.h 	return test_bit(J_ABORTED, &journal->j_state);
journal           724 fs/reiserfs/super.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal           764 fs/reiserfs/super.c 	if (journal->j_max_commit_age != journal->j_default_max_commit_age)
journal           765 fs/reiserfs/super.c 		seq_printf(seq, ",commit=%d", journal->j_max_commit_age);
journal          1439 fs/reiserfs/super.c 	struct reiserfs_journal *journal = SB_JOURNAL(s);
journal          1505 fs/reiserfs/super.c 		journal->j_max_commit_age = commit_max_age;
journal          1506 fs/reiserfs/super.c 		journal->j_max_trans_age = commit_max_age;
journal          1509 fs/reiserfs/super.c 		journal->j_max_commit_age = journal->j_default_max_commit_age;
journal          1510 fs/reiserfs/super.c 		journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
journal          1555 fs/reiserfs/super.c 		if (reiserfs_is_journal_aborted(journal)) {
journal          1556 fs/reiserfs/super.c 			err = journal->j_errno;
journal           479 include/linux/f2fs_fs.h 	struct f2fs_journal journal;
journal          1279 include/linux/jbd2.h int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
journal          1281 include/linux/jbd2.h int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
journal          1282 include/linux/jbd2.h void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
journal          1288 include/linux/jbd2.h void __jbd2_journal_clean_checkpoint_list(journal_t *journal, bool destroy);
journal          1290 include/linux/jbd2.h void jbd2_journal_destroy_checkpoint(journal_t *journal);
journal          1397 include/linux/jbd2.h extern int	   jbd2_journal_load       (journal_t *journal);
journal          1399 include/linux/jbd2.h extern int	   jbd2_journal_recover    (journal_t *journal);
journal          1419 include/linux/jbd2.h extern int	   jbd2_journal_begin_ordered_truncate(journal_t *journal,
journal          1422 include/linux/jbd2.h extern void	   jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
journal          1480 include/linux/jbd2.h extern void	jbd2_journal_switch_revoke_table(journal_t *journal);
journal          1481 include/linux/jbd2.h extern void	jbd2_clear_buffer_revoked_flags(journal_t *journal);
journal          1490 include/linux/jbd2.h int jbd2_log_start_commit(journal_t *journal, tid_t tid);
journal          1491 include/linux/jbd2.h int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
journal          1492 include/linux/jbd2.h int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
journal          1493 include/linux/jbd2.h int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
journal          1494 include/linux/jbd2.h int jbd2_transaction_committed(journal_t *journal, tid_t tid);
journal          1495 include/linux/jbd2.h int jbd2_complete_transaction(journal_t *journal, tid_t tid);
journal          1496 include/linux/jbd2.h int jbd2_log_do_checkpoint(journal_t *journal);
journal          1497 include/linux/jbd2.h int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
journal          1499 include/linux/jbd2.h void __jbd2_log_wait_for_space(journal_t *journal);
journal          1513 include/linux/jbd2.h static inline int is_journal_aborted(journal_t *journal)
journal          1515 include/linux/jbd2.h 	return journal->j_flags & JBD2_ABORT;
journal          1548 include/linux/jbd2.h extern size_t journal_tag_bytes(journal_t *journal);
journal          1555 include/linux/jbd2.h static inline int jbd2_journal_has_csum_v2or3(journal_t *journal)
journal          1557 include/linux/jbd2.h 	WARN_ON_ONCE(jbd2_journal_has_csum_v2or3_feature(journal) &&
journal          1558 include/linux/jbd2.h 		     journal->j_chksum_driver == NULL);
journal          1560 include/linux/jbd2.h 	return journal->j_chksum_driver != NULL;
journal          1573 include/linux/jbd2.h static inline int jbd2_space_needed(journal_t *journal)
journal          1575 include/linux/jbd2.h 	int nblocks = journal->j_max_transaction_buffers;
journal          1582 include/linux/jbd2.h static inline unsigned long jbd2_log_space_left(journal_t *journal)
journal          1585 include/linux/jbd2.h 	long free = journal->j_free - 32;
journal          1587 include/linux/jbd2.h 	if (journal->j_committing_transaction) {
journal          1588 include/linux/jbd2.h 		unsigned long committing = atomic_read(&journal->
journal          1614 include/linux/jbd2.h static inline u32 jbd2_chksum(journal_t *journal, u32 crc,
journal          1623 include/linux/jbd2.h 	BUG_ON(crypto_shash_descsize(journal->j_chksum_driver) >
journal          1626 include/linux/jbd2.h 	desc.shash.tfm = journal->j_chksum_driver;
journal          1636 include/linux/jbd2.h static inline tid_t  jbd2_get_latest_transaction(journal_t *journal)
journal          1640 include/linux/jbd2.h 	read_lock(&journal->j_state_lock);
journal          1641 include/linux/jbd2.h 	tid = journal->j_commit_request;
journal          1642 include/linux/jbd2.h 	if (journal->j_running_transaction)
journal          1643 include/linux/jbd2.h 		tid = journal->j_running_transaction->t_tid;
journal          1644 include/linux/jbd2.h 	read_unlock(&journal->j_state_lock);
journal            16 include/trace/events/jbd2.h 	TP_PROTO(journal_t *journal, int result),
journal            18 include/trace/events/jbd2.h 	TP_ARGS(journal, result),
journal            26 include/trace/events/jbd2.h 		__entry->dev		= journal->j_fs_dev->bd_dev;
journal            36 include/trace/events/jbd2.h 	TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
journal            38 include/trace/events/jbd2.h 	TP_ARGS(journal, commit_transaction),
journal            47 include/trace/events/jbd2.h 		__entry->dev		= journal->j_fs_dev->bd_dev;
journal            59 include/trace/events/jbd2.h 	TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
journal            61 include/trace/events/jbd2.h 	TP_ARGS(journal, commit_transaction)
journal            66 include/trace/events/jbd2.h 	TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
journal            68 include/trace/events/jbd2.h 	TP_ARGS(journal, commit_transaction)
journal            73 include/trace/events/jbd2.h 	TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
journal            75 include/trace/events/jbd2.h 	TP_ARGS(journal, commit_transaction)
journal            80 include/trace/events/jbd2.h 	TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
journal            82 include/trace/events/jbd2.h 	TP_ARGS(journal, commit_transaction)
journal            87 include/trace/events/jbd2.h 	TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
journal            89 include/trace/events/jbd2.h 	TP_ARGS(journal, commit_transaction)
journal            93 include/trace/events/jbd2.h 	TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
journal            95 include/trace/events/jbd2.h 	TP_ARGS(journal, commit_transaction),
journal           105 include/trace/events/jbd2.h 		__entry->dev		= journal->j_fs_dev->bd_dev;
journal           108 include/trace/events/jbd2.h 		__entry->head		= journal->j_tail_sequence;
journal           315 include/trace/events/jbd2.h 	TP_PROTO(journal_t *journal, tid_t first_tid,
journal           318 include/trace/events/jbd2.h 	TP_ARGS(journal, first_tid, block_nr, freed),
journal           329 include/trace/events/jbd2.h 		__entry->dev		= journal->j_fs_dev->bd_dev;
journal           330 include/trace/events/jbd2.h 		__entry->tail_sequence	= journal->j_tail_sequence;
journal           344 include/trace/events/jbd2.h 	TP_PROTO(journal_t *journal, int write_op),
journal           346 include/trace/events/jbd2.h 	TP_ARGS(journal, write_op),
journal           354 include/trace/events/jbd2.h 		__entry->dev		= journal->j_fs_dev->bd_dev;