Lines Matching refs:bh
60 * "bh" may be NULL: a metadata block may have been freed from memory
65 struct buffer_head *bh, ext3_fsblk_t blocknr)
71 BUFFER_TRACE(bh, "enter");
73 jbd_debug(4, "forgetting bh %p: is_metadata = %d, mode %o, "
75 bh, is_metadata, inode->i_mode,
85 if (bh) {
86 BUFFER_TRACE(bh, "call journal_forget");
87 return ext3_journal_forget(handle, bh);
95 BUFFER_TRACE(bh, "call ext3_journal_revoke");
96 err = ext3_journal_revoke(handle, blocknr, bh);
100 BUFFER_TRACE(bh, "exit");
239 struct buffer_head *bh;
242 static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
245 p->bh = bh;
333 * Function fills the array of triples <key, p, bh> and returns %NULL
338 * number (it points into struct inode for i==0 and into the bh->b_data
339 * for i>0) and chain[i].bh points to the buffer_head of i-th indirect
359 struct buffer_head *bh;
367 bh = sb_bread(sb, le32_to_cpu(p->key));
368 if (!bh)
373 add_chain(++p, bh, (__le32*)bh->b_data + *++offsets);
381 brelse(bh);
413 __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
425 if (ind->bh)
426 return ind->bh->b_blocknr;
600 struct buffer_head *bh;
620 bh = sb_getblk(inode->i_sb, new_blocks[n-1]);
621 branch[n].bh = bh;
622 lock_buffer(bh);
623 BUFFER_TRACE(bh, "call get_create_access");
624 err = ext3_journal_get_create_access(handle, bh);
626 unlock_buffer(bh);
627 brelse(bh);
631 memset(bh->b_data, 0, blocksize);
632 branch[n].p = (__le32 *) bh->b_data + offsets[n];
645 BUFFER_TRACE(bh, "marking uptodate");
646 set_buffer_uptodate(bh);
647 unlock_buffer(bh);
649 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
650 err = ext3_journal_dirty_metadata(handle, bh);
659 BUFFER_TRACE(branch[i].bh, "call journal_forget");
660 ext3_journal_forget(handle, branch[i].bh);
698 if (where->bh) {
699 BUFFER_TRACE(where->bh, "get_write_access");
700 err = ext3_journal_get_write_access(handle, where->bh);
735 if (where->bh) {
745 BUFFER_TRACE(where->bh, "call ext3_journal_dirty_metadata");
746 err = ext3_journal_dirty_metadata(handle, where->bh);
760 BUFFER_TRACE(where[i].bh, "call journal_forget");
761 ext3_journal_forget(handle, where[i].bh);
866 brelse(partial->bh);
935 BUFFER_TRACE(partial->bh, "call brelse");
936 brelse(partial->bh);
1023 struct buffer_head *bh;
1024 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
1025 if (!bh) {
1040 lock_buffer(bh);
1041 BUFFER_TRACE(bh, "call get_create_access");
1042 fatal = ext3_journal_get_create_access(handle, bh);
1043 if (!fatal && !buffer_uptodate(bh)) {
1044 memset(bh->b_data,0,inode->i_sb->s_blocksize);
1045 set_buffer_uptodate(bh);
1047 unlock_buffer(bh);
1048 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
1049 err = ext3_journal_dirty_metadata(handle, bh);
1053 BUFFER_TRACE(bh, "not a new buffer");
1057 brelse(bh);
1058 bh = NULL;
1060 return bh;
1069 struct buffer_head * bh;
1071 bh = ext3_getblk(handle, inode, block, create, err);
1072 if (!bh)
1073 return bh;
1074 if (buffer_uptodate(bh))
1075 return bh;
1076 ll_rw_block(READ_META, 1, &bh);
1077 wait_on_buffer(bh);
1078 if (buffer_uptodate(bh))
1079 return bh;
1080 put_bh(bh);
1091 struct buffer_head *bh))
1093 struct buffer_head *bh;
1099 for ( bh = head, block_start = 0;
1100 ret == 0 && (bh != head || !block_start);
1101 block_start = block_end, bh = next)
1103 next = bh->b_this_page;
1106 if (partial && !buffer_uptodate(bh))
1110 err = (*fn)(handle, bh);
1143 struct buffer_head *bh)
1145 if (!buffer_mapped(bh) || buffer_freed(bh))
1147 return ext3_journal_get_write_access(handle, bh);
1184 int ext3_journal_dirty_data(handle_t *handle, struct buffer_head *bh)
1186 int err = journal_dirty_data(handle, bh);
1189 bh, handle,err);
1194 static int commit_write_fn(handle_t *handle, struct buffer_head *bh)
1196 if (!buffer_mapped(bh) || buffer_freed(bh))
1198 set_buffer_uptodate(bh);
1199 return ext3_journal_dirty_metadata(handle, bh);
1346 static int bget_one(handle_t *handle, struct buffer_head *bh)
1348 get_bh(bh);
1352 static int bput_one(handle_t *handle, struct buffer_head *bh)
1354 put_bh(bh);
1358 static int journal_dirty_data_fn(handle_t *handle, struct buffer_head *bh)
1360 if (buffer_mapped(bh))
1361 return ext3_journal_dirty_data(handle, bh);
1716 struct buffer_head *bh;
1738 bh = page_buffers(page);
1741 bh = bh->b_this_page;
1747 if (buffer_freed(bh)) {
1748 BUFFER_TRACE(bh, "freed: skip");
1752 if (!buffer_mapped(bh)) {
1753 BUFFER_TRACE(bh, "unmapped");
1754 ext3_get_block(inode, iblock, bh, 0);
1756 if (!buffer_mapped(bh)) {
1757 BUFFER_TRACE(bh, "still unmapped");
1764 set_buffer_uptodate(bh);
1766 if (!buffer_uptodate(bh)) {
1768 ll_rw_block(READ, 1, &bh);
1769 wait_on_buffer(bh);
1771 if (!buffer_uptodate(bh))
1776 BUFFER_TRACE(bh, "get write access");
1777 err = ext3_journal_get_write_access(handle, bh);
1783 BUFFER_TRACE(bh, "zeroed end of block");
1787 err = ext3_journal_dirty_metadata(handle, bh);
1790 err = ext3_journal_dirty_data(handle, bh);
1791 mark_buffer_dirty(bh);
1836 * partially truncated blocks - in @chain[].bh and pointers to
1844 * (@chain[i].p+1 .. end of @chain[i].bh->b_data)
1869 for (p=partial; p>chain && all_zeroes((__le32*)p->bh->b_data,p->p); p--)
1886 brelse(partial->bh);
1902 struct buffer_head *bh, ext3_fsblk_t block_to_free,
1907 if (bh) {
1908 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
1909 ext3_journal_dirty_metadata(handle, bh);
1913 if (bh) {
1914 BUFFER_TRACE(bh, "retaking write access");
1915 ext3_journal_get_write_access(handle, bh);
1930 struct buffer_head *bh;
1933 bh = sb_find_get_block(inode->i_sb, nr);
1934 ext3_forget(handle, 0, inode, bh, nr);
2038 struct buffer_head *bh;
2047 bh = sb_bread(inode->i_sb, nr);
2053 if (!bh) {
2061 BUFFER_TRACE(bh, "free child branches");
2062 ext3_free_branches(handle, inode, bh,
2063 (__le32*)bh->b_data,
2064 (__le32*)bh->b_data + addr_per_block,
2086 ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
2270 BUFFER_TRACE(partial->bh, "get_write_access");
2271 ext3_free_branches(handle, inode, partial->bh,
2278 ext3_free_branches(handle, inode, partial->bh, partial->p + 1,
2279 (__le32*)partial->bh->b_data+addr_per_block,
2281 BUFFER_TRACE(partial->bh, "call brelse");
2282 brelse (partial->bh);
2342 struct buffer_head *bh;
2362 bh = EXT3_SB(sb)->s_group_desc[group_desc];
2363 if (!bh) {
2369 gdp = (struct ext3_group_desc *)bh->b_data;
2393 struct buffer_head *bh;
2399 bh = sb_getblk(inode->i_sb, block);
2400 if (!bh) {
2407 if (!buffer_uptodate(bh)) {
2408 lock_buffer(bh);
2409 if (buffer_uptodate(bh)) {
2411 unlock_buffer(bh);
2430 inodes_per_buffer = bh->b_size /
2465 memset(bh->b_data, 0, bh->b_size);
2466 set_buffer_uptodate(bh);
2467 unlock_buffer(bh);
2478 get_bh(bh);
2479 bh->b_end_io = end_buffer_read_sync;
2480 submit_bh(READ_META, bh);
2481 wait_on_buffer(bh);
2482 if (!buffer_uptodate(bh)) {
2487 brelse(bh);
2492 iloc->bh = bh;
2544 struct buffer_head *bh;
2555 bh = iloc.bh;
2583 brelse (bh);
2626 brelse (bh);
2666 brelse (iloc.bh);
2680 * The caller must have write access to iloc->bh.
2688 struct buffer_head *bh = iloc->bh;
2782 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
2783 rc = ext3_journal_dirty_metadata(handle, bh);
2789 brelse (bh);
2986 * Give this, we know that the caller already has write access to iloc->bh.
2993 /* the do_update_inode consumes one bh->b_count */
2994 get_bh(iloc->bh);
2998 put_bh(iloc->bh);
3004 * iloc->bh. This _must_ be cleaned up later.
3015 BUFFER_TRACE(iloc->bh, "get_write_access");
3016 err = ext3_journal_get_write_access(handle, iloc->bh);
3018 brelse(iloc->bh);
3019 iloc->bh = NULL;