Lines Matching refs:bh
58 * "bh" may be NULL: a metadata block may have been freed from memory
63 struct buffer_head *bh, ext4_fsblk_t blocknr)
69 BUFFER_TRACE(bh, "enter");
71 jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
73 bh, is_metadata, inode->i_mode,
83 if (bh) {
84 BUFFER_TRACE(bh, "call jbd2_journal_forget");
85 return ext4_journal_forget(handle, bh);
93 BUFFER_TRACE(bh, "call ext4_journal_revoke");
94 err = ext4_journal_revoke(handle, blocknr, bh);
98 BUFFER_TRACE(bh, "exit");
237 struct buffer_head *bh;
240 static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
243 p->bh = bh;
331 * Function fills the array of triples <key, p, bh> and returns %NULL
336 * number (it points into struct inode for i==0 and into the bh->b_data
337 * for i>0) and chain[i].bh points to the buffer_head of i-th indirect
357 struct buffer_head *bh;
365 bh = sb_bread(sb, le32_to_cpu(p->key));
366 if (!bh)
371 add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
379 brelse(bh);
411 __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
423 if (ind->bh)
424 return ind->bh->b_blocknr;
598 struct buffer_head *bh;
618 bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
619 branch[n].bh = bh;
620 lock_buffer(bh);
621 BUFFER_TRACE(bh, "call get_create_access");
622 err = ext4_journal_get_create_access(handle, bh);
624 unlock_buffer(bh);
625 brelse(bh);
629 memset(bh->b_data, 0, blocksize);
630 branch[n].p = (__le32 *) bh->b_data + offsets[n];
643 BUFFER_TRACE(bh, "marking uptodate");
644 set_buffer_uptodate(bh);
645 unlock_buffer(bh);
647 BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata");
648 err = ext4_journal_dirty_metadata(handle, bh);
657 BUFFER_TRACE(branch[i].bh, "call jbd2_journal_forget");
658 ext4_journal_forget(handle, branch[i].bh);
696 if (where->bh) {
697 BUFFER_TRACE(where->bh, "get_write_access");
698 err = ext4_journal_get_write_access(handle, where->bh);
733 if (where->bh) {
743 BUFFER_TRACE(where->bh, "call ext4_journal_dirty_metadata");
744 err = ext4_journal_dirty_metadata(handle, where->bh);
758 BUFFER_TRACE(where[i].bh, "call jbd2_journal_forget");
759 ext4_journal_forget(handle, where[i].bh);
865 brelse(partial->bh);
934 BUFFER_TRACE(partial->bh, "call brelse");
935 brelse(partial->bh);
1022 struct buffer_head *bh;
1023 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
1024 if (!bh) {
1039 lock_buffer(bh);
1040 BUFFER_TRACE(bh, "call get_create_access");
1041 fatal = ext4_journal_get_create_access(handle, bh);
1042 if (!fatal && !buffer_uptodate(bh)) {
1043 memset(bh->b_data,0,inode->i_sb->s_blocksize);
1044 set_buffer_uptodate(bh);
1046 unlock_buffer(bh);
1047 BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata");
1048 err = ext4_journal_dirty_metadata(handle, bh);
1052 BUFFER_TRACE(bh, "not a new buffer");
1056 brelse(bh);
1057 bh = NULL;
1059 return bh;
1068 struct buffer_head * bh;
1070 bh = ext4_getblk(handle, inode, block, create, err);
1071 if (!bh)
1072 return bh;
1073 if (buffer_uptodate(bh))
1074 return bh;
1075 ll_rw_block(READ_META, 1, &bh);
1076 wait_on_buffer(bh);
1077 if (buffer_uptodate(bh))
1078 return bh;
1079 put_bh(bh);
1090 struct buffer_head *bh))
1092 struct buffer_head *bh;
1098 for ( bh = head, block_start = 0;
1099 ret == 0 && (bh != head || !block_start);
1100 block_start = block_end, bh = next)
1102 next = bh->b_this_page;
1105 if (partial && !buffer_uptodate(bh))
1109 err = (*fn)(handle, bh);
1142 struct buffer_head *bh)
1144 if (!buffer_mapped(bh) || buffer_freed(bh))
1146 return ext4_journal_get_write_access(handle, bh);
1183 int ext4_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1185 int err = jbd2_journal_dirty_data(handle, bh);
1188 bh, handle,err);
1193 static int commit_write_fn(handle_t *handle, struct buffer_head *bh)
1195 if (!buffer_mapped(bh) || buffer_freed(bh))
1197 set_buffer_uptodate(bh);
1198 return ext4_journal_dirty_metadata(handle, bh);
1345 static int bget_one(handle_t *handle, struct buffer_head *bh)
1347 get_bh(bh);
1351 static int bput_one(handle_t *handle, struct buffer_head *bh)
1353 put_bh(bh);
1357 static int jbd2_journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
1359 if (buffer_mapped(bh))
1360 return ext4_journal_dirty_data(handle, bh);
1715 struct buffer_head *bh;
1741 bh = page_buffers(page);
1744 bh = bh->b_this_page;
1750 if (buffer_freed(bh)) {
1751 BUFFER_TRACE(bh, "freed: skip");
1755 if (!buffer_mapped(bh)) {
1756 BUFFER_TRACE(bh, "unmapped");
1757 ext4_get_block(inode, iblock, bh, 0);
1759 if (!buffer_mapped(bh)) {
1760 BUFFER_TRACE(bh, "still unmapped");
1767 set_buffer_uptodate(bh);
1769 if (!buffer_uptodate(bh)) {
1771 ll_rw_block(READ, 1, &bh);
1772 wait_on_buffer(bh);
1774 if (!buffer_uptodate(bh))
1779 BUFFER_TRACE(bh, "get write access");
1780 err = ext4_journal_get_write_access(handle, bh);
1790 BUFFER_TRACE(bh, "zeroed end of block");
1794 err = ext4_journal_dirty_metadata(handle, bh);
1797 err = ext4_journal_dirty_data(handle, bh);
1798 mark_buffer_dirty(bh);
1843 * partially truncated blocks - in @chain[].bh and pointers to
1851 * (@chain[i].p+1 .. end of @chain[i].bh->b_data)
1876 for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
1893 brelse(partial->bh);
1909 struct buffer_head *bh, ext4_fsblk_t block_to_free,
1914 if (bh) {
1915 BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata");
1916 ext4_journal_dirty_metadata(handle, bh);
1920 if (bh) {
1921 BUFFER_TRACE(bh, "retaking write access");
1922 ext4_journal_get_write_access(handle, bh);
1937 struct buffer_head *bh;
1940 bh = sb_find_get_block(inode->i_sb, nr);
1941 ext4_forget(handle, 0, inode, bh, nr);
2045 struct buffer_head *bh;
2054 bh = sb_bread(inode->i_sb, nr);
2060 if (!bh) {
2068 BUFFER_TRACE(bh, "free child branches");
2069 ext4_free_branches(handle, inode, bh,
2070 (__le32*)bh->b_data,
2071 (__le32*)bh->b_data + addr_per_block,
2093 ext4_forget(handle, 1, inode, bh, bh->b_blocknr);
2280 BUFFER_TRACE(partial->bh, "get_write_access");
2281 ext4_free_branches(handle, inode, partial->bh,
2288 ext4_free_branches(handle, inode, partial->bh, partial->p + 1,
2289 (__le32*)partial->bh->b_data+addr_per_block,
2291 BUFFER_TRACE(partial->bh, "call brelse");
2292 brelse (partial->bh);
2352 struct buffer_head *bh;
2372 bh = EXT4_SB(sb)->s_group_desc[group_desc];
2373 if (!bh) {
2379 gdp = (struct ext4_group_desc *)((__u8 *)bh->b_data +
2404 struct buffer_head *bh;
2410 bh = sb_getblk(inode->i_sb, block);
2411 if (!bh) {
2418 if (!buffer_uptodate(bh)) {
2419 lock_buffer(bh);
2420 if (buffer_uptodate(bh)) {
2422 unlock_buffer(bh);
2441 inodes_per_buffer = bh->b_size /
2476 memset(bh->b_data, 0, bh->b_size);
2477 set_buffer_uptodate(bh);
2478 unlock_buffer(bh);
2489 get_bh(bh);
2490 bh->b_end_io = end_buffer_read_sync;
2491 submit_bh(READ_META, bh);
2492 wait_on_buffer(bh);
2493 if (!buffer_uptodate(bh)) {
2498 brelse(bh);
2503 iloc->bh = bh;
2536 struct buffer_head *bh;
2547 bh = iloc.bh;
2575 brelse (bh);
2622 brelse (bh);
2662 brelse (iloc.bh);
2676 * The caller must have write access to iloc->bh.
2684 struct buffer_head *bh = iloc->bh;
2781 BUFFER_TRACE(bh, "call ext4_journal_dirty_metadata");
2782 rc = ext4_journal_dirty_metadata(handle, bh);
2788 brelse (bh);
2988 * Give this, we know that the caller already has write access to iloc->bh.
2995 /* the do_update_inode consumes one bh->b_count */
2996 get_bh(iloc->bh);
3000 put_bh(iloc->bh);
3006 * iloc->bh. This _must_ be cleaned up later.
3017 BUFFER_TRACE(iloc->bh, "get_write_access");
3018 err = ext4_journal_get_write_access(handle, iloc->bh);
3020 brelse(iloc->bh);
3021 iloc->bh = NULL;