mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-28 02:32:09 -04:00
Merge branch 'master' into for-next
Sync with Linus' tree so that patches against newer codebase can be applied. Signed-off-by: Jiri Kosina <[email protected]>
This commit is contained in:
Jiri Kosina
commit
9938b04472
17915 changed files with 1318191 additions and 705330 deletions
|
|
@ -81,11 +81,11 @@ static void release_buffer_page(struct buffer_head *bh)
|
|||
if (!trylock_page(page))
|
||||
goto nope;
|
||||
|
||||
page_cache_get(page);
|
||||
get_page(page);
|
||||
__brelse(bh);
|
||||
try_to_free_buffers(page);
|
||||
unlock_page(page);
|
||||
page_cache_release(page);
|
||||
put_page(page);
|
||||
return;
|
||||
|
||||
nope:
|
||||
|
|
@ -131,14 +131,12 @@ static int journal_submit_commit_record(journal_t *journal,
|
|||
if (is_journal_aborted(journal))
|
||||
return 0;
|
||||
|
||||
bh = jbd2_journal_get_descriptor_buffer(journal);
|
||||
bh = jbd2_journal_get_descriptor_buffer(commit_transaction,
|
||||
JBD2_COMMIT_BLOCK);
|
||||
if (!bh)
|
||||
return 1;
|
||||
|
||||
tmp = (struct commit_header *)bh->b_data;
|
||||
tmp->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
|
||||
tmp->h_blocktype = cpu_to_be32(JBD2_COMMIT_BLOCK);
|
||||
tmp->h_sequence = cpu_to_be32(commit_transaction->t_tid);
|
||||
tmp->h_commit_sec = cpu_to_be64(now.tv_sec);
|
||||
tmp->h_commit_nsec = cpu_to_be32(now.tv_nsec);
|
||||
|
||||
|
|
@ -222,7 +220,7 @@ static int journal_submit_data_buffers(journal_t *journal,
|
|||
spin_lock(&journal->j_list_lock);
|
||||
list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
|
||||
mapping = jinode->i_vfs_inode->i_mapping;
|
||||
set_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
|
||||
jinode->i_flags |= JI_COMMIT_RUNNING;
|
||||
spin_unlock(&journal->j_list_lock);
|
||||
/*
|
||||
* submit the inode data buffers. We use writepage
|
||||
|
|
@ -236,8 +234,8 @@ static int journal_submit_data_buffers(journal_t *journal,
|
|||
ret = err;
|
||||
spin_lock(&journal->j_list_lock);
|
||||
J_ASSERT(jinode->i_transaction == commit_transaction);
|
||||
clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
|
||||
smp_mb__after_atomic();
|
||||
jinode->i_flags &= ~JI_COMMIT_RUNNING;
|
||||
smp_mb();
|
||||
wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
|
||||
}
|
||||
spin_unlock(&journal->j_list_lock);
|
||||
|
|
@ -258,7 +256,7 @@ static int journal_finish_inode_data_buffers(journal_t *journal,
|
|||
/* For locking, see the comment in journal_submit_data_buffers() */
|
||||
spin_lock(&journal->j_list_lock);
|
||||
list_for_each_entry(jinode, &commit_transaction->t_inode_list, i_list) {
|
||||
set_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
|
||||
jinode->i_flags |= JI_COMMIT_RUNNING;
|
||||
spin_unlock(&journal->j_list_lock);
|
||||
err = filemap_fdatawait(jinode->i_vfs_inode->i_mapping);
|
||||
if (err) {
|
||||
|
|
@ -274,8 +272,8 @@ static int journal_finish_inode_data_buffers(journal_t *journal,
|
|||
ret = err;
|
||||
}
|
||||
spin_lock(&journal->j_list_lock);
|
||||
clear_bit(__JI_COMMIT_RUNNING, &jinode->i_flags);
|
||||
smp_mb__after_atomic();
|
||||
jinode->i_flags &= ~JI_COMMIT_RUNNING;
|
||||
smp_mb();
|
||||
wake_up_bit(&jinode->i_flags, __JI_COMMIT_RUNNING);
|
||||
}
|
||||
|
||||
|
|
@ -319,22 +317,6 @@ static void write_tag_block(journal_t *j, journal_block_tag_t *tag,
|
|||
tag->t_blocknr_high = cpu_to_be32((block >> 31) >> 1);
|
||||
}
|
||||
|
||||
static void jbd2_descr_block_csum_set(journal_t *j,
|
||||
struct buffer_head *bh)
|
||||
{
|
||||
struct jbd2_journal_block_tail *tail;
|
||||
__u32 csum;
|
||||
|
||||
if (!jbd2_journal_has_csum_v2or3(j))
|
||||
return;
|
||||
|
||||
tail = (struct jbd2_journal_block_tail *)(bh->b_data + j->j_blocksize -
|
||||
sizeof(struct jbd2_journal_block_tail));
|
||||
tail->t_checksum = 0;
|
||||
csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
|
||||
tail->t_checksum = cpu_to_be32(csum);
|
||||
}
|
||||
|
||||
static void jbd2_block_tag_csum_set(journal_t *j, journal_block_tag_t *tag,
|
||||
struct buffer_head *bh, __u32 sequence)
|
||||
{
|
||||
|
|
@ -379,7 +361,6 @@ void jbd2_journal_commit_transaction(journal_t *journal)
|
|||
ktime_t start_time;
|
||||
u64 commit_time;
|
||||
char *tagp = NULL;
|
||||
journal_header_t *header;
|
||||
journal_block_tag_t *tag = NULL;
|
||||
int space_left = 0;
|
||||
int first_tag = 0;
|
||||
|
|
@ -554,8 +535,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
|
|||
jbd2_journal_abort(journal, err);
|
||||
|
||||
blk_start_plug(&plug);
|
||||
jbd2_journal_write_revoke_records(journal, commit_transaction,
|
||||
&log_bufs, WRITE_SYNC);
|
||||
jbd2_journal_write_revoke_records(commit_transaction, &log_bufs);
|
||||
|
||||
jbd_debug(3, "JBD2: commit phase 2b\n");
|
||||
|
||||
|
|
@ -616,7 +596,9 @@ void jbd2_journal_commit_transaction(journal_t *journal)
|
|||
|
||||
jbd_debug(4, "JBD2: get descriptor\n");
|
||||
|
||||
descriptor = jbd2_journal_get_descriptor_buffer(journal);
|
||||
descriptor = jbd2_journal_get_descriptor_buffer(
|
||||
commit_transaction,
|
||||
JBD2_DESCRIPTOR_BLOCK);
|
||||
if (!descriptor) {
|
||||
jbd2_journal_abort(journal, -EIO);
|
||||
continue;
|
||||
|
|
@ -625,11 +607,6 @@ void jbd2_journal_commit_transaction(journal_t *journal)
|
|||
jbd_debug(4, "JBD2: got buffer %llu (%p)\n",
|
||||
(unsigned long long)descriptor->b_blocknr,
|
||||
descriptor->b_data);
|
||||
header = (journal_header_t *)descriptor->b_data;
|
||||
header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
|
||||
header->h_blocktype = cpu_to_be32(JBD2_DESCRIPTOR_BLOCK);
|
||||
header->h_sequence = cpu_to_be32(commit_transaction->t_tid);
|
||||
|
||||
tagp = &descriptor->b_data[sizeof(journal_header_t)];
|
||||
space_left = descriptor->b_size -
|
||||
sizeof(journal_header_t);
|
||||
|
|
@ -721,7 +698,7 @@ void jbd2_journal_commit_transaction(journal_t *journal)
|
|||
|
||||
tag->t_flags |= cpu_to_be16(JBD2_FLAG_LAST_TAG);
|
||||
|
||||
jbd2_descr_block_csum_set(journal, descriptor);
|
||||
jbd2_descriptor_block_csum_set(journal, descriptor);
|
||||
start_journal_io:
|
||||
for (i = 0; i < bufs; i++) {
|
||||
struct buffer_head *bh = wbuf[i];
|
||||
|
|
|
|||
|
|
@ -805,10 +805,13 @@ int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,
|
|||
* But we don't bother doing that, so there will be coherency problems with
|
||||
* mmaps of blockdevs which hold live JBD-controlled filesystems.
|
||||
*/
|
||||
struct buffer_head *jbd2_journal_get_descriptor_buffer(journal_t *journal)
|
||||
struct buffer_head *
|
||||
jbd2_journal_get_descriptor_buffer(transaction_t *transaction, int type)
|
||||
{
|
||||
journal_t *journal = transaction->t_journal;
|
||||
struct buffer_head *bh;
|
||||
unsigned long long blocknr;
|
||||
journal_header_t *header;
|
||||
int err;
|
||||
|
||||
err = jbd2_journal_next_log_block(journal, &blocknr);
|
||||
|
|
@ -821,12 +824,31 @@ struct buffer_head *jbd2_journal_get_descriptor_buffer(journal_t *journal)
|
|||
return NULL;
|
||||
lock_buffer(bh);
|
||||
memset(bh->b_data, 0, journal->j_blocksize);
|
||||
header = (journal_header_t *)bh->b_data;
|
||||
header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
|
||||
header->h_blocktype = cpu_to_be32(type);
|
||||
header->h_sequence = cpu_to_be32(transaction->t_tid);
|
||||
set_buffer_uptodate(bh);
|
||||
unlock_buffer(bh);
|
||||
BUFFER_TRACE(bh, "return this buffer");
|
||||
return bh;
|
||||
}
|
||||
|
||||
void jbd2_descriptor_block_csum_set(journal_t *j, struct buffer_head *bh)
|
||||
{
|
||||
struct jbd2_journal_block_tail *tail;
|
||||
__u32 csum;
|
||||
|
||||
if (!jbd2_journal_has_csum_v2or3(j))
|
||||
return;
|
||||
|
||||
tail = (struct jbd2_journal_block_tail *)(bh->b_data + j->j_blocksize -
|
||||
sizeof(struct jbd2_journal_block_tail));
|
||||
tail->t_checksum = 0;
|
||||
csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
|
||||
tail->t_checksum = cpu_to_be32(csum);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return tid of the oldest transaction in the journal and block in the journal
|
||||
* where the transaction starts.
|
||||
|
|
@ -1408,11 +1430,12 @@ out:
|
|||
/**
|
||||
* jbd2_mark_journal_empty() - Mark on disk journal as empty.
|
||||
* @journal: The journal to update.
|
||||
* @write_op: With which operation should we write the journal sb
|
||||
*
|
||||
* Update a journal's dynamic superblock fields to show that journal is empty.
|
||||
* Write updated superblock to disk waiting for IO to complete.
|
||||
*/
|
||||
static void jbd2_mark_journal_empty(journal_t *journal)
|
||||
static void jbd2_mark_journal_empty(journal_t *journal, int write_op)
|
||||
{
|
||||
journal_superblock_t *sb = journal->j_superblock;
|
||||
|
||||
|
|
@ -1430,7 +1453,7 @@ static void jbd2_mark_journal_empty(journal_t *journal)
|
|||
sb->s_start = cpu_to_be32(0);
|
||||
read_unlock(&journal->j_state_lock);
|
||||
|
||||
jbd2_write_superblock(journal, WRITE_FUA);
|
||||
jbd2_write_superblock(journal, write_op);
|
||||
|
||||
/* Log is no longer empty */
|
||||
write_lock(&journal->j_state_lock);
|
||||
|
|
@ -1716,7 +1739,13 @@ int jbd2_journal_destroy(journal_t *journal)
|
|||
if (journal->j_sb_buffer) {
|
||||
if (!is_journal_aborted(journal)) {
|
||||
mutex_lock(&journal->j_checkpoint_mutex);
|
||||
jbd2_mark_journal_empty(journal);
|
||||
|
||||
write_lock(&journal->j_state_lock);
|
||||
journal->j_tail_sequence =
|
||||
++journal->j_transaction_sequence;
|
||||
write_unlock(&journal->j_state_lock);
|
||||
|
||||
jbd2_mark_journal_empty(journal, WRITE_FLUSH_FUA);
|
||||
mutex_unlock(&journal->j_checkpoint_mutex);
|
||||
} else
|
||||
err = -EIO;
|
||||
|
|
@ -1975,7 +2004,7 @@ int jbd2_journal_flush(journal_t *journal)
|
|||
* the magic code for a fully-recovered superblock. Any future
|
||||
* commits of data to the journal will restore the current
|
||||
* s_start value. */
|
||||
jbd2_mark_journal_empty(journal);
|
||||
jbd2_mark_journal_empty(journal, WRITE_FUA);
|
||||
mutex_unlock(&journal->j_checkpoint_mutex);
|
||||
write_lock(&journal->j_state_lock);
|
||||
J_ASSERT(!journal->j_running_transaction);
|
||||
|
|
@ -2021,7 +2050,7 @@ int jbd2_journal_wipe(journal_t *journal, int write)
|
|||
if (write) {
|
||||
/* Lock to make assertions happy... */
|
||||
mutex_lock(&journal->j_checkpoint_mutex);
|
||||
jbd2_mark_journal_empty(journal);
|
||||
jbd2_mark_journal_empty(journal, WRITE_FUA);
|
||||
mutex_unlock(&journal->j_checkpoint_mutex);
|
||||
}
|
||||
|
||||
|
|
@ -2192,7 +2221,7 @@ void jbd2_journal_ack_err(journal_t *journal)
|
|||
|
||||
int jbd2_journal_blocks_per_page(struct inode *inode)
|
||||
{
|
||||
return 1 << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
|
||||
return 1 << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -2565,7 +2594,7 @@ void jbd2_journal_release_jbd_inode(journal_t *journal,
|
|||
restart:
|
||||
spin_lock(&journal->j_list_lock);
|
||||
/* Is commit writing out inode - we have to wait */
|
||||
if (test_bit(__JI_COMMIT_RUNNING, &jinode->i_flags)) {
|
||||
if (jinode->i_flags & JI_COMMIT_RUNNING) {
|
||||
wait_queue_head_t *wq;
|
||||
DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING);
|
||||
wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING);
|
||||
|
|
|
|||
|
|
@ -174,8 +174,7 @@ static int jread(struct buffer_head **bhp, journal_t *journal,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int jbd2_descr_block_csum_verify(journal_t *j,
|
||||
void *buf)
|
||||
static int jbd2_descriptor_block_csum_verify(journal_t *j, void *buf)
|
||||
{
|
||||
struct jbd2_journal_block_tail *tail;
|
||||
__be32 provided;
|
||||
|
|
@ -522,8 +521,8 @@ static int do_one_pass(journal_t *journal,
|
|||
descr_csum_size =
|
||||
sizeof(struct jbd2_journal_block_tail);
|
||||
if (descr_csum_size > 0 &&
|
||||
!jbd2_descr_block_csum_verify(journal,
|
||||
bh->b_data)) {
|
||||
!jbd2_descriptor_block_csum_verify(journal,
|
||||
bh->b_data)) {
|
||||
printk(KERN_ERR "JBD2: Invalid checksum "
|
||||
"recovering block %lu in log\n",
|
||||
next_log_block);
|
||||
|
|
@ -811,26 +810,6 @@ static int do_one_pass(journal_t *journal,
|
|||
return err;
|
||||
}
|
||||
|
||||
static int jbd2_revoke_block_csum_verify(journal_t *j,
|
||||
void *buf)
|
||||
{
|
||||
struct jbd2_journal_revoke_tail *tail;
|
||||
__be32 provided;
|
||||
__u32 calculated;
|
||||
|
||||
if (!jbd2_journal_has_csum_v2or3(j))
|
||||
return 1;
|
||||
|
||||
tail = (struct jbd2_journal_revoke_tail *)(buf + j->j_blocksize -
|
||||
sizeof(struct jbd2_journal_revoke_tail));
|
||||
provided = tail->r_checksum;
|
||||
tail->r_checksum = 0;
|
||||
calculated = jbd2_chksum(j, j->j_csum_seed, buf, j->j_blocksize);
|
||||
tail->r_checksum = provided;
|
||||
|
||||
return provided == cpu_to_be32(calculated);
|
||||
}
|
||||
|
||||
/* Scan a revoke record, marking all blocks mentioned as revoked. */
|
||||
|
||||
static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,
|
||||
|
|
@ -846,11 +825,11 @@ static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,
|
|||
offset = sizeof(jbd2_journal_revoke_header_t);
|
||||
rcount = be32_to_cpu(header->r_count);
|
||||
|
||||
if (!jbd2_revoke_block_csum_verify(journal, header))
|
||||
if (!jbd2_descriptor_block_csum_verify(journal, header))
|
||||
return -EFSBADCRC;
|
||||
|
||||
if (jbd2_journal_has_csum_v2or3(journal))
|
||||
csum_size = sizeof(struct jbd2_journal_revoke_tail);
|
||||
csum_size = sizeof(struct jbd2_journal_block_tail);
|
||||
if (rcount > journal->j_blocksize - csum_size)
|
||||
return -EINVAL;
|
||||
max = rcount;
|
||||
|
|
|
|||
|
|
@ -122,11 +122,11 @@ struct jbd2_revoke_table_s
|
|||
|
||||
|
||||
#ifdef __KERNEL__
|
||||
static void write_one_revoke_record(journal_t *, transaction_t *,
|
||||
static void write_one_revoke_record(transaction_t *,
|
||||
struct list_head *,
|
||||
struct buffer_head **, int *,
|
||||
struct jbd2_revoke_record_s *, int);
|
||||
static void flush_descriptor(journal_t *, struct buffer_head *, int, int);
|
||||
struct jbd2_revoke_record_s *);
|
||||
static void flush_descriptor(journal_t *, struct buffer_head *, int);
|
||||
#endif
|
||||
|
||||
/* Utility functions to maintain the revoke table */
|
||||
|
|
@ -519,11 +519,10 @@ void jbd2_journal_switch_revoke_table(journal_t *journal)
|
|||
* Write revoke records to the journal for all entries in the current
|
||||
* revoke hash, deleting the entries as we go.
|
||||
*/
|
||||
void jbd2_journal_write_revoke_records(journal_t *journal,
|
||||
transaction_t *transaction,
|
||||
struct list_head *log_bufs,
|
||||
int write_op)
|
||||
void jbd2_journal_write_revoke_records(transaction_t *transaction,
|
||||
struct list_head *log_bufs)
|
||||
{
|
||||
journal_t *journal = transaction->t_journal;
|
||||
struct buffer_head *descriptor;
|
||||
struct jbd2_revoke_record_s *record;
|
||||
struct jbd2_revoke_table_s *revoke;
|
||||
|
|
@ -544,16 +543,15 @@ void jbd2_journal_write_revoke_records(journal_t *journal,
|
|||
while (!list_empty(hash_list)) {
|
||||
record = (struct jbd2_revoke_record_s *)
|
||||
hash_list->next;
|
||||
write_one_revoke_record(journal, transaction, log_bufs,
|
||||
&descriptor, &offset,
|
||||
record, write_op);
|
||||
write_one_revoke_record(transaction, log_bufs,
|
||||
&descriptor, &offset, record);
|
||||
count++;
|
||||
list_del(&record->hash);
|
||||
kmem_cache_free(jbd2_revoke_record_cache, record);
|
||||
}
|
||||
}
|
||||
if (descriptor)
|
||||
flush_descriptor(journal, descriptor, offset, write_op);
|
||||
flush_descriptor(journal, descriptor, offset);
|
||||
jbd_debug(1, "Wrote %d revoke records\n", count);
|
||||
}
|
||||
|
||||
|
|
@ -562,18 +560,16 @@ void jbd2_journal_write_revoke_records(journal_t *journal,
|
|||
* block if the old one is full or if we have not already created one.
|
||||
*/
|
||||
|
||||
static void write_one_revoke_record(journal_t *journal,
|
||||
transaction_t *transaction,
|
||||
static void write_one_revoke_record(transaction_t *transaction,
|
||||
struct list_head *log_bufs,
|
||||
struct buffer_head **descriptorp,
|
||||
int *offsetp,
|
||||
struct jbd2_revoke_record_s *record,
|
||||
int write_op)
|
||||
struct jbd2_revoke_record_s *record)
|
||||
{
|
||||
journal_t *journal = transaction->t_journal;
|
||||
int csum_size = 0;
|
||||
struct buffer_head *descriptor;
|
||||
int sz, offset;
|
||||
journal_header_t *header;
|
||||
|
||||
/* If we are already aborting, this all becomes a noop. We
|
||||
still need to go round the loop in
|
||||
|
|
@ -587,7 +583,7 @@ static void write_one_revoke_record(journal_t *journal,
|
|||
|
||||
/* Do we need to leave space at the end for a checksum? */
|
||||
if (jbd2_journal_has_csum_v2or3(journal))
|
||||
csum_size = sizeof(struct jbd2_journal_revoke_tail);
|
||||
csum_size = sizeof(struct jbd2_journal_block_tail);
|
||||
|
||||
if (jbd2_has_feature_64bit(journal))
|
||||
sz = 8;
|
||||
|
|
@ -597,19 +593,16 @@ static void write_one_revoke_record(journal_t *journal,
|
|||
/* Make sure we have a descriptor with space left for the record */
|
||||
if (descriptor) {
|
||||
if (offset + sz > journal->j_blocksize - csum_size) {
|
||||
flush_descriptor(journal, descriptor, offset, write_op);
|
||||
flush_descriptor(journal, descriptor, offset);
|
||||
descriptor = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
if (!descriptor) {
|
||||
descriptor = jbd2_journal_get_descriptor_buffer(journal);
|
||||
descriptor = jbd2_journal_get_descriptor_buffer(transaction,
|
||||
JBD2_REVOKE_BLOCK);
|
||||
if (!descriptor)
|
||||
return;
|
||||
header = (journal_header_t *)descriptor->b_data;
|
||||
header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
|
||||
header->h_blocktype = cpu_to_be32(JBD2_REVOKE_BLOCK);
|
||||
header->h_sequence = cpu_to_be32(transaction->t_tid);
|
||||
|
||||
/* Record it so that we can wait for IO completion later */
|
||||
BUFFER_TRACE(descriptor, "file in log_bufs");
|
||||
|
|
@ -630,21 +623,6 @@ static void write_one_revoke_record(journal_t *journal,
|
|||
*offsetp = offset;
|
||||
}
|
||||
|
||||
static void jbd2_revoke_csum_set(journal_t *j, struct buffer_head *bh)
|
||||
{
|
||||
struct jbd2_journal_revoke_tail *tail;
|
||||
__u32 csum;
|
||||
|
||||
if (!jbd2_journal_has_csum_v2or3(j))
|
||||
return;
|
||||
|
||||
tail = (struct jbd2_journal_revoke_tail *)(bh->b_data + j->j_blocksize -
|
||||
sizeof(struct jbd2_journal_revoke_tail));
|
||||
tail->r_checksum = 0;
|
||||
csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
|
||||
tail->r_checksum = cpu_to_be32(csum);
|
||||
}
|
||||
|
||||
/*
|
||||
* Flush a revoke descriptor out to the journal. If we are aborting,
|
||||
* this is a noop; otherwise we are generating a buffer which needs to
|
||||
|
|
@ -654,7 +632,7 @@ static void jbd2_revoke_csum_set(journal_t *j, struct buffer_head *bh)
|
|||
|
||||
static void flush_descriptor(journal_t *journal,
|
||||
struct buffer_head *descriptor,
|
||||
int offset, int write_op)
|
||||
int offset)
|
||||
{
|
||||
jbd2_journal_revoke_header_t *header;
|
||||
|
||||
|
|
@ -665,12 +643,12 @@ static void flush_descriptor(journal_t *journal,
|
|||
|
||||
header = (jbd2_journal_revoke_header_t *)descriptor->b_data;
|
||||
header->r_count = cpu_to_be32(offset);
|
||||
jbd2_revoke_csum_set(journal, descriptor);
|
||||
jbd2_descriptor_block_csum_set(journal, descriptor);
|
||||
|
||||
set_buffer_jwrite(descriptor);
|
||||
BUFFER_TRACE(descriptor, "write");
|
||||
set_buffer_dirty(descriptor);
|
||||
write_dirty_buffer(descriptor, write_op);
|
||||
write_dirty_buffer(descriptor, WRITE_SYNC);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -764,13 +764,11 @@ void jbd2_journal_unlock_updates (journal_t *journal)
|
|||
|
||||
static void warn_dirty_buffer(struct buffer_head *bh)
|
||||
{
|
||||
char b[BDEVNAME_SIZE];
|
||||
|
||||
printk(KERN_WARNING
|
||||
"JBD2: Spotted dirty metadata buffer (dev = %s, blocknr = %llu). "
|
||||
"JBD2: Spotted dirty metadata buffer (dev = %pg, blocknr = %llu). "
|
||||
"There's a risk of filesystem corruption in case of system "
|
||||
"crash.\n",
|
||||
bdevname(bh->b_bdev, b), (unsigned long long)bh->b_blocknr);
|
||||
bh->b_bdev, (unsigned long long)bh->b_blocknr);
|
||||
}
|
||||
|
||||
/* Call t_frozen trigger and copy buffer data into jh->b_frozen_data. */
|
||||
|
|
@ -968,14 +966,8 @@ repeat:
|
|||
if (!frozen_buffer) {
|
||||
JBUFFER_TRACE(jh, "allocate memory for buffer");
|
||||
jbd_unlock_bh_state(bh);
|
||||
frozen_buffer = jbd2_alloc(jh2bh(jh)->b_size, GFP_NOFS);
|
||||
if (!frozen_buffer) {
|
||||
printk(KERN_ERR "%s: OOM for frozen_buffer\n",
|
||||
__func__);
|
||||
JBUFFER_TRACE(jh, "oom!");
|
||||
error = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
frozen_buffer = jbd2_alloc(jh2bh(jh)->b_size,
|
||||
GFP_NOFS | __GFP_NOFAIL);
|
||||
goto repeat;
|
||||
}
|
||||
jh->b_frozen_data = frozen_buffer;
|
||||
|
|
@ -1009,7 +1001,8 @@ out:
|
|||
}
|
||||
|
||||
/* Fast check whether buffer is already attached to the required transaction */
|
||||
static bool jbd2_write_access_granted(handle_t *handle, struct buffer_head *bh)
|
||||
static bool jbd2_write_access_granted(handle_t *handle, struct buffer_head *bh,
|
||||
bool undo)
|
||||
{
|
||||
struct journal_head *jh;
|
||||
bool ret = false;
|
||||
|
|
@ -1036,6 +1029,9 @@ static bool jbd2_write_access_granted(handle_t *handle, struct buffer_head *bh)
|
|||
jh = READ_ONCE(bh->b_private);
|
||||
if (!jh)
|
||||
goto out;
|
||||
/* For undo access buffer must have data copied */
|
||||
if (undo && !jh->b_committed_data)
|
||||
goto out;
|
||||
if (jh->b_transaction != handle->h_transaction &&
|
||||
jh->b_next_transaction != handle->h_transaction)
|
||||
goto out;
|
||||
|
|
@ -1073,7 +1069,7 @@ int jbd2_journal_get_write_access(handle_t *handle, struct buffer_head *bh)
|
|||
struct journal_head *jh;
|
||||
int rc;
|
||||
|
||||
if (jbd2_write_access_granted(handle, bh))
|
||||
if (jbd2_write_access_granted(handle, bh, false))
|
||||
return 0;
|
||||
|
||||
jh = jbd2_journal_add_journal_head(bh);
|
||||
|
|
@ -1210,7 +1206,7 @@ int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
|
|||
char *committed_data = NULL;
|
||||
|
||||
JBUFFER_TRACE(jh, "entry");
|
||||
if (jbd2_write_access_granted(handle, bh))
|
||||
if (jbd2_write_access_granted(handle, bh, true))
|
||||
return 0;
|
||||
|
||||
jh = jbd2_journal_add_journal_head(bh);
|
||||
|
|
@ -1224,15 +1220,9 @@ int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
|
|||
goto out;
|
||||
|
||||
repeat:
|
||||
if (!jh->b_committed_data) {
|
||||
committed_data = jbd2_alloc(jh2bh(jh)->b_size, GFP_NOFS);
|
||||
if (!committed_data) {
|
||||
printk(KERN_ERR "%s: No memory for committed data\n",
|
||||
__func__);
|
||||
err = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
if (!jh->b_committed_data)
|
||||
committed_data = jbd2_alloc(jh2bh(jh)->b_size,
|
||||
GFP_NOFS|__GFP_NOFAIL);
|
||||
|
||||
jbd_lock_bh_state(bh);
|
||||
if (!jh->b_committed_data) {
|
||||
|
|
@ -1937,8 +1927,8 @@ out:
|
|||
* @journal: journal for operation
|
||||
* @page: to try and free
|
||||
* @gfp_mask: we use the mask to detect how hard should we try to release
|
||||
* buffers. If __GFP_WAIT and __GFP_FS is set, we wait for commit code to
|
||||
* release the buffers.
|
||||
* buffers. If __GFP_DIRECT_RECLAIM and __GFP_FS is set, we wait for commit
|
||||
* code to release the buffers.
|
||||
*
|
||||
*
|
||||
* For all the buffers on this page,
|
||||
|
|
@ -2152,6 +2142,7 @@ static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh,
|
|||
|
||||
if (!buffer_dirty(bh)) {
|
||||
/* bdflush has written it. We can drop it now */
|
||||
__jbd2_journal_remove_checkpoint(jh);
|
||||
goto zap_buffer;
|
||||
}
|
||||
|
||||
|
|
@ -2181,6 +2172,7 @@ static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh,
|
|||
/* The orphan record's transaction has
|
||||
* committed. We can cleanse this buffer */
|
||||
clear_buffer_jbddirty(bh);
|
||||
__jbd2_journal_remove_checkpoint(jh);
|
||||
goto zap_buffer;
|
||||
}
|
||||
}
|
||||
|
|
@ -2271,7 +2263,7 @@ int jbd2_journal_invalidatepage(journal_t *journal,
|
|||
struct buffer_head *head, *bh, *next;
|
||||
unsigned int stop = offset + length;
|
||||
unsigned int curr_off = 0;
|
||||
int partial_page = (offset || length < PAGE_CACHE_SIZE);
|
||||
int partial_page = (offset || length < PAGE_SIZE);
|
||||
int may_free = 1;
|
||||
int ret = 0;
|
||||
|
||||
|
|
@ -2280,7 +2272,7 @@ int jbd2_journal_invalidatepage(journal_t *journal,
|
|||
if (!page_has_buffers(page))
|
||||
return 0;
|
||||
|
||||
BUG_ON(stop > PAGE_CACHE_SIZE || stop < length);
|
||||
BUG_ON(stop > PAGE_SIZE || stop < length);
|
||||
|
||||
/* We will potentially be playing with lists other than just the
|
||||
* data lists (especially for journaled data mode), so be
|
||||
|
|
|
|||
Loading…
Reference in a new issue