自学教程：C++ submit_bh函数代码示例

int gfs2_meta_read(struct gfs2_glock *gl, u64 blkno, int flags,		   struct buffer_head **bhp){	struct gfs2_sbd *sdp = gl->gl_sbd;	struct buffer_head *bh;	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))		return -EIO;	*bhp = bh = gfs2_getbuf(gl, blkno, CREATE);	lock_buffer(bh);	if (buffer_uptodate(bh)) {		unlock_buffer(bh);		return 0;	}	bh->b_end_io = end_buffer_read_sync;	get_bh(bh);	submit_bh(READ_SYNC | (1 << BIO_RW_META), bh);	if (!(flags & DIO_WAIT))		return 0;	wait_on_buffer(bh);	if (unlikely(!buffer_uptodate(bh))) {		struct gfs2_trans *tr = current->journal_info;		if (tr && tr->tr_touched)			gfs2_io_error_bh(sdp, bh);		brelse(bh);		return -EIO;	}	return 0;}

static int gfs2_aspace_writepage(struct page *page, struct writeback_control *wbc){	int err;	struct buffer_head *bh, *head;	int nr_underway = 0;	int write_op = (1 << BIO_RW_META) | ((wbc->sync_mode == WB_SYNC_ALL ?			WRITE_SYNC_PLUG : WRITE));	BUG_ON(!PageLocked(page));	BUG_ON(!page_has_buffers(page));	head = page_buffers(page);	bh = head;	do {		if (!buffer_mapped(bh))			continue;		/*		 * If it's a fully non-blocking write attempt and we cannot		 * lock the buffer then redirty the page.  Note that this can		 * potentially cause a busy-wait loop from pdflush and kswapd		 * activity, but those code paths have their own higher-level		 * throttling.		 */		if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {			lock_buffer(bh);		} else if (!trylock_buffer(bh)) {			redirty_page_for_writepage(wbc, page);			continue;		}		if (test_clear_buffer_dirty(bh)) {			mark_buffer_async_write(bh);		} else {			unlock_buffer(bh);		}	} while ((bh = bh->b_this_page) != head);	/*	 * The page and its buffers are protected by PageWriteback(), so we can	 * drop the bh refcounts early.	 */	BUG_ON(PageWriteback(page));	set_page_writeback(page);	do {		struct buffer_head *next = bh->b_this_page;		if (buffer_async_write(bh)) {			submit_bh(write_op, bh);			nr_underway++;		}		bh = next;	} while (bh != head);	unlock_page(page);	err = 0;	if (nr_underway == 0)		end_page_writeback(page);	return err;}

static void gfs2_metapath_ra(struct gfs2_glock *gl,			     const struct buffer_head *bh, const __be64 *pos){	struct buffer_head *rabh;	const __be64 *endp = (const __be64 *)(bh->b_data + bh->b_size);	const __be64 *t;	for (t = pos; t < endp; t++) {		if (!*t)			continue;		rabh = gfs2_getbuf(gl, be64_to_cpu(*t), CREATE);		if (trylock_buffer(rabh)) {			if (!buffer_uptodate(rabh)) {				rabh->b_end_io = end_buffer_read_sync;				submit_bh(REQ_OP_READ,					  REQ_RAHEAD | REQ_META | REQ_PRIO,					  rabh);				continue;			}			unlock_buffer(rabh);		}		brelse(rabh);	}}

/* * Write the MMP block using WRITE_SYNC to try to get the block on-disk * faster. */static int write_mmp_block(struct super_block *sb, struct buffer_head *bh){	struct mmp_struct *mmp = (struct mmp_struct *)(bh->b_data);	/*	 * We protect against freezing so that we don't create dirty buffers	 * on frozen filesystem.	 */	sb_start_write(sb);	ext4_mmp_csum_set(sb, mmp);	mark_buffer_dirty(bh);	lock_buffer(bh);	bh->b_end_io = end_buffer_write_sync;	get_bh(bh);#ifdef FEATURE_STORAGE_META_LOG	if( bh && bh->b_bdev && bh->b_bdev->bd_disk)		set_metadata_rw_status(bh->b_bdev->bd_disk->first_minor, WAIT_WRITE_CNT);#endif	submit_bh(WRITE_SYNC | REQ_META | REQ_PRIO, bh);	wait_on_buffer(bh);	sb_end_write(sb);	if (unlikely(!buffer_uptodate(bh)))		return 1;	return 0;}

static void journal_do_submit_data(struct buffer_head **wbuf, int bufs){	int i;	for (i = 0; i < bufs; i++) {		wbuf[i]->b_end_io = end_buffer_write_sync;		/* We use-up our safety reference in submit_bh() */		submit_bh(WRITE, wbuf[i]);	}}

static intnilfs_mdt_submit_block(struct inode *inode, unsigned long blkoff,		       int mode, struct buffer_head **out_bh){	struct buffer_head *bh;	unsigned long blknum = 0;	int ret = -ENOMEM;	bh = nilfs_grab_buffer(inode, inode->i_mapping, blkoff, 0);	if (unlikely(!bh))		goto failed;	ret = -EEXIST; /* internal code */	if (buffer_uptodate(bh))		goto out;	if (mode == READA) {		if (!trylock_buffer(bh)) {			ret = -EBUSY;			goto failed_bh;		}	} else /* mode == READ */		lock_buffer(bh);	if (buffer_uptodate(bh)) {		unlock_buffer(bh);		goto out;	}	if (!buffer_mapped(bh)) { /* unused buffer */		ret = nilfs_bmap_lookup(NILFS_I(inode)->i_bmap, blkoff,					&blknum);		if (unlikely(ret)) {			unlock_buffer(bh);			goto failed_bh;		}		bh->b_bdev = NILFS_MDT(inode)->mi_nilfs->ns_bdev;		bh->b_blocknr = blknum;		set_buffer_mapped(bh);	}	bh->b_end_io = end_buffer_read_sync;	get_bh(bh);	submit_bh(mode, bh);	ret = 0; out:	get_bh(bh);	*out_bh = bh; failed_bh:	unlock_page(bh->b_page);	page_cache_release(bh->b_page);	brelse(bh); failed:	return ret;}

static int ufs_fmp_run(struct device *dev, uint32_t mode, uint8_t *data,			uint32_t len, uint32_t write){	int ret = 0;	struct ufs_hba *hba;	struct ufs_fmp_work *work;	struct Scsi_Host *host;	static struct buffer_head *bh;	work = dev_get_drvdata(dev);	if (!work) {		dev_err(dev, "Fail to get work from platform device/n");		return -ENODEV;	}	host = work->host;	hba = shost_priv(host);	hba->self_test_mode = mode;	bh = __getblk(work->bdev, work->sector, FMP_BLK_SIZE);	if (!bh) {		dev_err(dev, "Fail to get block from bdev/n");		return -ENODEV;	}	hba->self_test_bh = bh;	get_bh(bh);	if (write == WRITE_MODE) {		memcpy(bh->b_data, data, len);		set_buffer_dirty(bh);		sync_dirty_buffer(bh);		if (buffer_req(bh) && !buffer_uptodate(bh)) {			dev_err(dev, "IO error syncing for FMP fips write/n");			ret = -EIO;			goto out;		}		memset(bh->b_data, 0, FMP_BLK_SIZE);	} else {		lock_buffer(bh);		bh->b_end_io = end_buffer_read_sync;		submit_bh(READ_SYNC, bh);		wait_on_buffer(bh);		if (unlikely(!buffer_uptodate(bh))) {			ret = -EIO;			goto out;		}		memcpy(data, bh->b_data, len);	}out:	hba->self_test_mode = 0;	hba->self_test_bh = NULL;	put_bh(bh);	return ret;}

static intnilfs_mdt_submit_block(struct inode *inode, unsigned long blkoff,		       int mode, int mode_flags, struct buffer_head **out_bh){	struct buffer_head *bh;	__u64 blknum = 0;	int ret = -ENOMEM;	bh = nilfs_grab_buffer(inode, inode->i_mapping, blkoff, 0);	if (unlikely(!bh))		goto failed;	ret = -EEXIST; /* internal code */	if (buffer_uptodate(bh))		goto out;	if (mode_flags & REQ_RAHEAD) {		if (!trylock_buffer(bh)) {			ret = -EBUSY;			goto failed_bh;		}	} else /* mode == READ */		lock_buffer(bh);	if (buffer_uptodate(bh)) {		unlock_buffer(bh);		goto out;	}	ret = nilfs_bmap_lookup(NILFS_I(inode)->i_bmap, blkoff, &blknum);	if (unlikely(ret)) {		unlock_buffer(bh);		goto failed_bh;	}	map_bh(bh, inode->i_sb, (sector_t)blknum);	bh->b_end_io = end_buffer_read_sync;	get_bh(bh);	submit_bh(mode, mode_flags, bh);	ret = 0;	trace_nilfs2_mdt_submit_block(inode, inode->i_ino, blkoff, mode); out:	get_bh(bh);	*out_bh = bh; failed_bh:	unlock_page(bh->b_page);	put_page(bh->b_page);	brelse(bh); failed:	return ret;}

int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr,			      sector_t pblocknr, struct buffer_head **pbh){	struct buffer_head *bh;	struct inode *inode = NILFS_BTNC_I(btnc);	int err;	bh = nilfs_grab_buffer(inode, btnc, blocknr, 1 << BH_NILFS_Node);	if (unlikely(!bh))		return -ENOMEM;	err = -EEXIST; /* internal code */	if (buffer_uptodate(bh) || buffer_dirty(bh))		goto found;	if (pblocknr == 0) {		pblocknr = blocknr;		if (inode->i_ino != NILFS_DAT_INO) {			struct inode *dat =				nilfs_dat_inode(NILFS_I_NILFS(inode));			/* blocknr is a virtual block number */			err = nilfs_dat_translate(dat, blocknr, &pblocknr);			if (unlikely(err)) {				brelse(bh);				goto out_locked;			}		}	}	lock_buffer(bh);	if (buffer_uptodate(bh)) {		unlock_buffer(bh);		err = -EEXIST; /* internal code */		goto found;	}	set_buffer_mapped(bh);	bh->b_bdev = NILFS_I_NILFS(inode)->ns_bdev;	bh->b_blocknr = pblocknr; /* set block address for read */	bh->b_end_io = end_buffer_read_sync;	get_bh(bh);	submit_bh(READ, bh);	bh->b_blocknr = blocknr; /* set back to the given block address */	err = 0;found:	*pbh = bh;out_locked:	unlock_page(bh->b_page);	page_cache_release(bh->b_page);	return err;}

/* * Write the MMP block using WRITE_SYNC to try to get the block on-disk * faster. */static int write_mmp_block(struct buffer_head *bh){	mark_buffer_dirty(bh);	lock_buffer(bh);	bh->b_end_io = end_buffer_write_sync;	get_bh(bh);	submit_bh(WRITE_SYNC, bh);	wait_on_buffer(bh);	if (unlikely(!buffer_uptodate(bh)))		return 1;	return 0;}

/* * nilfs_gccache_submit_read_data() - add data buffer and submit read request * @inode - gc inode * @blkoff - dummy offset treated as the key for the page cache * @pbn - physical block number of the block * @vbn - virtual block number of the block, 0 for non-virtual block * @out_bh - indirect pointer to a buffer_head struct to receive the results * * Description: nilfs_gccache_submit_read_data() registers the data buffer * specified by @pbn to the GC pagecache with the key @blkoff. * This function sets @vbn (@pbn if @vbn is zero) in b_blocknr of the buffer. * * Return Value: On success, 0 is returned. On Error, one of the following * negative error code is returned. * * %-EIO - I/O error. * * %-ENOMEM - Insufficient amount of memory available. * * %-ENOENT - The block specified with @pbn does not exist. */int nilfs_gccache_submit_read_data(struct inode *inode, sector_t blkoff,				   sector_t pbn, __u64 vbn,				   struct buffer_head **out_bh){	struct buffer_head *bh;	int err;	bh = nilfs_grab_buffer(inode, inode->i_mapping, blkoff, 0);	if (unlikely(!bh))		return -ENOMEM;	if (buffer_uptodate(bh))		goto out;	if (pbn == 0) {		struct the_nilfs *nilfs = inode->i_sb->s_fs_info;		err = nilfs_dat_translate(nilfs->ns_dat, vbn, &pbn);		if (unlikely(err)) { /* -EIO, -ENOMEM, -ENOENT */			brelse(bh);			goto failed;		}	}	lock_buffer(bh);	if (buffer_uptodate(bh)) {		unlock_buffer(bh);		goto out;	}	if (!buffer_mapped(bh)) {		bh->b_bdev = inode->i_sb->s_bdev;		set_buffer_mapped(bh);	}	bh->b_blocknr = pbn;	bh->b_end_io = end_buffer_read_sync;	get_bh(bh);	submit_bh(READ, bh);	if (vbn)		bh->b_blocknr = vbn; out:	err = 0;	*out_bh = bh; failed:	unlock_page(bh->b_page);	page_cache_release(bh->b_page);	return err;}

int ocfs2_write_block(struct ocfs2_super *osb, struct buffer_head *bh,		      struct inode *inode){	int ret = 0;	mlog_entry("(bh->b_blocknr = %llu, inode=%p)/n",		   (unsigned long long)bh->b_blocknr, inode);	BUG_ON(bh->b_blocknr < OCFS2_SUPER_BLOCK_BLKNO);	BUG_ON(buffer_jbd(bh));	/* No need to check for a soft readonly file system here. non	 * journalled writes are only ever done on system files which	 * can get modified during recovery even if read-only. */	if (ocfs2_is_hard_readonly(osb)) {		ret = -EROFS;		goto out;	}	mutex_lock(&OCFS2_I(inode)->ip_io_mutex);	lock_buffer(bh);	set_buffer_uptodate(bh);	/* remove from dirty list before I/O. */	clear_buffer_dirty(bh);	get_bh(bh); /* for end_buffer_write_sync() */	bh->b_end_io = end_buffer_write_sync;	submit_bh(WRITE, bh);	wait_on_buffer(bh);	if (buffer_uptodate(bh)) {		ocfs2_set_buffer_uptodate(inode, bh);	} else {		/* We don't need to remove the clustered uptodate		 * information for this bh as it's not marked locally		 * uptodate. */		ret = -EIO;		put_bh(bh);	}	mutex_unlock(&OCFS2_I(inode)->ip_io_mutex);out:	mlog_exit(ret);	return ret;}

int ocfs2_write_block(struct ocfs2_super *osb, struct buffer_head *bh,		      struct ocfs2_caching_info *ci){	int ret = 0;	trace_ocfs2_write_block((unsigned long long)bh->b_blocknr, ci);	BUG_ON(bh->b_blocknr < OCFS2_SUPER_BLOCK_BLKNO);	BUG_ON(buffer_jbd(bh));	/* No need to check for a soft readonly file system here. non	 * journalled writes are only ever done on system files which	 * can get modified during recovery even if read-only. */	if (ocfs2_is_hard_readonly(osb)) {		ret = -EROFS;		mlog_errno(ret);		goto out;	}	ocfs2_metadata_cache_io_lock(ci);	lock_buffer(bh);	set_buffer_uptodate(bh);	/* remove from dirty list before I/O. */	clear_buffer_dirty(bh);	get_bh(bh); /* for end_buffer_write_sync() */	bh->b_end_io = end_buffer_write_sync;	submit_bh(REQ_OP_WRITE, 0, bh);	wait_on_buffer(bh);	if (buffer_uptodate(bh)) {		ocfs2_set_buffer_uptodate(ci, bh);	} else {		/* We don't need to remove the clustered uptodate		 * information for this bh as it's not marked locally		 * uptodate. */		ret = -EIO;		mlog_errno(ret);	}	ocfs2_metadata_cache_io_unlock(ci);out:	return ret;}

/* * Read the MMP block. It _must_ be read from disk and hence we clear the * uptodate flag on the buffer. */static int read_mmp_block(struct super_block *sb, struct buffer_head **bh,			  ext4_fsblk_t mmp_block){	struct mmp_struct *mmp;	int ret;	if (*bh)		clear_buffer_uptodate(*bh);	/* This would be sb_bread(sb, mmp_block), except we need to be sure	 * that the MD RAID device cache has been bypassed, and that the read	 * is not blocked in the elevator. */	if (!*bh) {		*bh = sb_getblk(sb, mmp_block);		if (!*bh) {			ret = -ENOMEM;			goto warn_exit;		}	}	get_bh(*bh);	lock_buffer(*bh);	(*bh)->b_end_io = end_buffer_read_sync;	submit_bh(READ_SYNC | REQ_META | REQ_PRIO, *bh);	wait_on_buffer(*bh);	if (!buffer_uptodate(*bh)) {		ret = -EIO;		goto warn_exit;	}	mmp = (struct mmp_struct *)((*bh)->b_data);	if (le32_to_cpu(mmp->mmp_magic) != EXT4_MMP_MAGIC) {		ret = -EFSCORRUPTED;		goto warn_exit;	}	if (!ext4_mmp_csum_verify(sb, mmp)) {		ret = -EFSBADCRC;		goto warn_exit;	}	return 0;warn_exit:	brelse(*bh);	*bh = NULL;	ext4_warning(sb, "Error %d while reading MMP block %llu",		     ret, mmp_block);	return ret;}

/* * Write the MMP block using WRITE_SYNC to try to get the block on-disk * faster. */static int write_mmp_block(struct buffer_head *bh){	mark_buffer_dirty(bh);	lock_buffer(bh);	bh->b_end_io = end_buffer_write_sync;	get_bh(bh);#ifdef FEATURE_STORAGE_META_LOG	set_metadata_rw_status(bh->b_bdev->bd_disk->first_minor, WAIT_WRITE_CNT);#endif	submit_bh(WRITE_SYNC, bh);	wait_on_buffer(bh);	if (unlikely(!buffer_uptodate(bh)))		return 1;	return 0;}

/* * Read the MMP block. It _must_ be read from disk and hence we clear the * uptodate flag on the buffer. */static int read_mmp_block(struct super_block *sb, struct buffer_head **bh,			  ext4_fsblk_t mmp_block){	struct mmp_struct *mmp;	if (*bh)		clear_buffer_uptodate(*bh);	/* This would be sb_bread(sb, mmp_block), except we need to be sure	 * that the MD RAID device cache has been bypassed, and that the read	 * is not blocked in the elevator. */	if (!*bh)		*bh = sb_getblk(sb, mmp_block);	if (!*bh)		return -ENOMEM;	if (*bh) {		get_bh(*bh);		lock_buffer(*bh);		(*bh)->b_end_io = end_buffer_read_sync;#ifdef FEATURE_STORAGE_META_LOG		if( (*bh) && (*bh)->b_bdev && (*bh)->b_bdev->bd_disk)			set_metadata_rw_status((*bh)->b_bdev->bd_disk->first_minor, WAIT_READ_CNT);#endif		submit_bh(READ_SYNC | REQ_META | REQ_PRIO, *bh);		wait_on_buffer(*bh);		if (!buffer_uptodate(*bh)) {			brelse(*bh);			*bh = NULL;		}	}	if (unlikely(!*bh)) {		ext4_warning(sb, "Error while reading MMP block %llu",			     mmp_block);		return -EIO;	}	mmp = (struct mmp_struct *)((*bh)->b_data);	if (le32_to_cpu(mmp->mmp_magic) != EXT4_MMP_MAGIC ||	    !ext4_mmp_csum_verify(sb, mmp))		return -EINVAL;	return 0;}

/* * Read the MMP block. It _must_ be read from disk and hence we clear the * uptodate flag on the buffer. */static int read_mmp_block(struct super_block *sb, struct buffer_head **bh,			  ext4_fsblk_t mmp_block){	struct mmp_struct *mmp;	if (*bh)		clear_buffer_uptodate(*bh);	/* This would be sb_bread(sb, mmp_block), except we need to be sure	 * that the MD RAID device cache has been bypassed, and that the read	 * is not blocked in the elevator. */	if (!*bh)		*bh = sb_getblk(sb, mmp_block);	if (!*bh)		return -ENOMEM;	if (*bh) {		get_bh(*bh);		lock_buffer(*bh);		(*bh)->b_end_io = end_buffer_read_sync;		submit_bh(READ_SYNC, *bh);		wait_on_buffer(*bh);		if (!buffer_uptodate(*bh)) {			brelse(*bh);			*bh = NULL;		}	}	if (unlikely(!*bh)) {		ext4_warning(sb, "Error while reading MMP block %llu",			     mmp_block);		return -EIO;	}	mmp = (struct mmp_struct *)((*bh)->b_data);	if (le32_to_cpu(mmp->mmp_magic) != EXT4_MMP_MAGIC ||	    !ext4_mmp_csum_verify(sb, mmp))		return -EINVAL;	return 0;}

/* * Write the MMP block using WRITE_SYNC to try to get the block on-disk * faster. */static int write_mmp_block(struct super_block *sb, struct buffer_head *bh){	struct mmp_struct *mmp = (struct mmp_struct *)(bh->b_data);	/*	 * We protect against freezing so that we don't create dirty buffers	 * on frozen filesystem.	 */	sb_start_write(sb);	ext4_mmp_csum_set(sb, mmp);	mark_buffer_dirty(bh);	lock_buffer(bh);	bh->b_end_io = end_buffer_write_sync;	get_bh(bh);	submit_bh(WRITE_SYNC | REQ_META | REQ_PRIO, bh);	wait_on_buffer(bh);	sb_end_write(sb);	if (unlikely(!buffer_uptodate(bh)))		return 1;	return 0;}

/* * write out a page to a file */static int write_page(struct bitmap *bitmap, struct page *page, int wait){	struct buffer_head *bh;	if (bitmap->file == NULL)		return write_sb_page(bitmap, page, wait);	bh = page_buffers(page);	while (bh && bh->b_blocknr) {		atomic_inc(&bitmap->pending_writes);		set_buffer_locked(bh);		set_buffer_mapped(bh);		submit_bh(WRITE, bh);		bh = bh->b_this_page;	}	if (wait) {		wait_event(bitmap->write_wait,			   atomic_read(&bitmap->pending_writes)==0);		return (bitmap->flags & BITMAP_WRITE_ERROR) ? -EIO : 0;	}	return 0;}

/* * Write super block and backups doesn't need to collaborate with journal, * so we don't need to lock ip_io_mutex and inode doesn't need to bea passed * into this function. */int ocfs2_write_super_or_backup(struct ocfs2_super *osb,				struct buffer_head *bh){	int ret = 0;	mlog_entry_void();	BUG_ON(buffer_jbd(bh));	ocfs2_check_super_or_backup(osb->sb, bh->b_blocknr);	if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb)) {		ret = -EROFS;		goto out;	}	lock_buffer(bh);	set_buffer_uptodate(bh);	/* remove from dirty list before I/O. */	clear_buffer_dirty(bh);	get_bh(bh); /* for end_buffer_write_sync() */	bh->b_end_io = end_buffer_write_sync;	submit_bh(WRITE, bh);	wait_on_buffer(bh);	if (!buffer_uptodate(bh)) {		ret = -EIO;		put_bh(bh);	}out:	mlog_exit(ret);	return ret;}

/* * Write super block and backups doesn't need to collaborate with journal, * so we don't need to lock ip_io_mutex and ci doesn't need to bea passed * into this function. */int ocfs2_write_super_or_backup(struct ocfs2_super *osb,				struct buffer_head *bh){	int ret = 0;	struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data;	BUG_ON(buffer_jbd(bh));	ocfs2_check_super_or_backup(osb->sb, bh->b_blocknr);	if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb)) {		ret = -EROFS;		mlog_errno(ret);		goto out;	}	lock_buffer(bh);	set_buffer_uptodate(bh);	/* remove from dirty list before I/O. */	clear_buffer_dirty(bh);	get_bh(bh); /* for end_buffer_write_sync() */	bh->b_end_io = end_buffer_write_sync;	ocfs2_compute_meta_ecc(osb->sb, bh->b_data, &di->i_check);	submit_bh(REQ_OP_WRITE, 0, bh);	wait_on_buffer(bh);	if (!buffer_uptodate(bh)) {		ret = -EIO;		mlog_errno(ret);	}out:	return ret;}

int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr,			      sector_t pblocknr, int mode,			      struct buffer_head **pbh, sector_t *submit_ptr){	struct buffer_head *bh;	struct inode *inode = NILFS_BTNC_I(btnc);	struct page *page;	int err;	bh = nilfs_grab_buffer(inode, btnc, blocknr, 1 << BH_NILFS_Node);	if (unlikely(!bh))		return -ENOMEM;	err = -EEXIST; 	page = bh->b_page;	if (buffer_uptodate(bh) || buffer_dirty(bh))		goto found;	if (pblocknr == 0) {		pblocknr = blocknr;		if (inode->i_ino != NILFS_DAT_INO) {			struct the_nilfs *nilfs = inode->i_sb->s_fs_info;						err = nilfs_dat_translate(nilfs->ns_dat, blocknr,						  &pblocknr);			if (unlikely(err)) {				brelse(bh);				goto out_locked;			}		}	}	if (mode == READA) {		if (pblocknr != *submit_ptr + 1 || !trylock_buffer(bh)) {			err = -EBUSY; 			brelse(bh);			goto out_locked;		}	} else { 		lock_buffer(bh);	}	if (buffer_uptodate(bh)) {		unlock_buffer(bh);		err = -EEXIST; 		goto found;	}	set_buffer_mapped(bh);	bh->b_bdev = inode->i_sb->s_bdev;	bh->b_blocknr = pblocknr; 	bh->b_end_io = end_buffer_read_sync;	get_bh(bh);	submit_bh(mode, bh);	bh->b_blocknr = blocknr; 	*submit_ptr = pblocknr;	err = 0;found:	*pbh = bh;out_locked:	unlock_page(page);	page_cache_release(page);	return err;}

//.........这里部分代码省略.........			/* A read-ahead request was made - if the			 * buffer is already under read-ahead from a			 * previously submitted request than we are			 * done here. */			if ((flags & OCFS2_BH_READAHEAD)			    && ocfs2_buffer_read_ahead(inode, bh))				continue;			lock_buffer(bh);			if (buffer_jbd(bh)) {#ifdef CATCH_BH_JBD_RACES				mlog(ML_ERROR, "block %llu had the JBD bit set "					       "while I was in lock_buffer!",				     (unsigned long long)bh->b_blocknr);				BUG();#else				unlock_buffer(bh);				continue;#endif			}			/* Re-check ocfs2_buffer_uptodate() as a			 * previously read-ahead buffer may have			 * completed I/O while we were waiting for the			 * buffer lock. */			if (!(flags & OCFS2_BH_IGNORE_CACHE)			    && !(flags & OCFS2_BH_READAHEAD)			    && ocfs2_buffer_uptodate(inode, bh)) {				unlock_buffer(bh);				continue;			}			clear_buffer_uptodate(bh);			get_bh(bh); /* for end_buffer_read_sync() */			if (validate)				set_buffer_needs_validate(bh);			bh->b_end_io = end_buffer_read_sync;			submit_bh(READ, bh);			continue;		}	}	status = 0;	for (i = (nr - 1); i >= 0; i--) {		bh = bhs[i];		if (!(flags & OCFS2_BH_READAHEAD)) {			/* We know this can't have changed as we hold the			 * inode sem. Avoid doing any work on the bh if the			 * journal has it. */			if (!buffer_jbd(bh))				wait_on_buffer(bh);			if (!buffer_uptodate(bh)) {				/* Status won't be cleared from here on out,				 * so we can safely record this and loop back				 * to cleanup the other buffers. Don't need to				 * remove the clustered uptodate information				 * for this bh as it's not marked locally				 * uptodate. */				status = -EIO;				put_bh(bh);				bhs[i] = NULL;				continue;			}			if (buffer_needs_validate(bh)) {				/* We never set NeedsValidate if the				 * buffer was held by the journal, so				 * that better not have changed */				BUG_ON(buffer_jbd(bh));				clear_buffer_needs_validate(bh);				status = validate(inode->i_sb, bh);				if (status) {					put_bh(bh);					bhs[i] = NULL;					continue;				}			}		}		/* Always set the buffer in the cache, even if it was		 * a forced read, or read-ahead which hasn't yet		 * completed. */		ocfs2_set_buffer_uptodate(inode, bh);	}	mutex_unlock(&OCFS2_I(inode)->ip_io_mutex);	mlog(ML_BH_IO, "block=(%llu), nr=(%d), cached=%s, flags=0x%x/n", 	     (unsigned long long)block, nr,	     ((flags & OCFS2_BH_IGNORE_CACHE) || ignore_cache) ? "no" : "yes",	     flags);bail:	mlog_exit(status);	return status;}

int ocfs2_read_blocks_sync(struct ocfs2_super *osb, u64 block,			   unsigned int nr, struct buffer_head *bhs[]){	int status = 0;	unsigned int i;	struct buffer_head *bh;	if (!nr) {		mlog(ML_BH_IO, "No buffers will be read!/n");		goto bail;	}	for (i = 0 ; i < nr ; i++) {		if (bhs[i] == NULL) {			bhs[i] = sb_getblk(osb->sb, block++);			if (bhs[i] == NULL) {				status = -EIO;				mlog_errno(status);				goto bail;			}		}		bh = bhs[i];		if (buffer_jbd(bh)) {			mlog(ML_BH_IO,			     "trying to sync read a jbd "			     "managed bh (blocknr = %llu), skipping/n",			     (unsigned long long)bh->b_blocknr);			continue;		}		if (buffer_dirty(bh)) {			/* This should probably be a BUG, or			 * at least return an error. */			mlog(ML_ERROR,			     "trying to sync read a dirty "			     "buffer! (blocknr = %llu), skipping/n",			     (unsigned long long)bh->b_blocknr);			continue;		}		lock_buffer(bh);		if (buffer_jbd(bh)) {			mlog(ML_ERROR,			     "block %llu had the JBD bit set "			     "while I was in lock_buffer!",			     (unsigned long long)bh->b_blocknr);			BUG();		}		clear_buffer_uptodate(bh);		get_bh(bh); /* for end_buffer_read_sync() */		bh->b_end_io = end_buffer_read_sync;		submit_bh(READ, bh);	}	for (i = nr; i > 0; i--) {		bh = bhs[i - 1];		/* No need to wait on the buffer if it's managed by JBD. */		if (!buffer_jbd(bh))			wait_on_buffer(bh);		if (!buffer_uptodate(bh)) {			/* Status won't be cleared from here on out,			 * so we can safely record this and loop back			 * to cleanup the other buffers. */			status = -EIO;			put_bh(bh);			bhs[i - 1] = NULL;		}	}bail:	return status;}

//.........这里部分代码省略.........		tag->t_flags = cpu_to_be32(tag_flag);		tagp += sizeof(journal_block_tag_t);		space_left -= sizeof(journal_block_tag_t);		if (first_tag) {			memcpy (tagp, journal->j_uuid, 16);			tagp += 16;			space_left -= 16;			first_tag = 0;		}		/* If there's no more to do, or if the descriptor is full,		   let the IO rip! */		if (bufs == journal->j_wbufsize ||		    commit_transaction->t_buffers == NULL ||		    space_left < sizeof(journal_block_tag_t) + 16) {			jbd_debug(4, "JBD: Submit %d IOs/n", bufs);			/* Write an end-of-descriptor marker before                           submitting the IOs.  "tag" still points to                           the last tag we set up. */			tag->t_flags |= cpu_to_be32(JFS_FLAG_LAST_TAG);start_journal_io:			for (i = 0; i < bufs; i++) {				struct buffer_head *bh = wbuf[i];				lock_buffer(bh);				clear_buffer_dirty(bh);				set_buffer_uptodate(bh);				bh->b_end_io = journal_end_buffer_io_sync;				submit_bh(WRITE_SYNC, bh);			}			cond_resched();			/* Force a new descriptor to be generated next                           time round the loop. */			descriptor = NULL;			bufs = 0;		}	}	blk_finish_plug(&plug);	/* Lo and behold: we have just managed to send a transaction to           the log.  Before we can commit it, wait for the IO so far to           complete.  Control buffers being written are on the           transaction's t_log_list queue, and metadata buffers are on           the t_iobuf_list queue.	   Wait for the buffers in reverse order.  That way we are	   less likely to be woken up until all IOs have completed, and	   so we incur less scheduling load.	*/	jbd_debug(3, "JBD: commit phase 4/n");	/*	 * akpm: these are BJ_IO, and j_list_lock is not needed.	 * See __journal_try_to_free_buffer.	 */wait_for_iobuf:	while (commit_transaction->t_iobuf_list != NULL) {		struct buffer_head *bh;

/* read a page from a file. * We both read the page, and attach buffers to the page to record the * address of each block (using bmap).  These addresses will be used * to write the block later, completely bypassing the filesystem. * This usage is similar to how swap files are handled, and allows us * to write to a file with no concerns of memory allocation failing. */static struct page *read_page(struct file *file, unsigned long index,			      struct bitmap *bitmap,			      unsigned long count){	struct page *page = NULL;	struct inode *inode = file->f_path.dentry->d_inode;	struct buffer_head *bh;	sector_t block;	PRINTK("read bitmap file (%dB @ %Lu)/n", (int)PAGE_SIZE,			(unsigned long long)index << PAGE_SHIFT);	page = alloc_page(GFP_KERNEL);	if (!page)		page = ERR_PTR(-ENOMEM);	if (IS_ERR(page))		goto out;	bh = alloc_page_buffers(page, 1<<inode->i_blkbits, 0);	if (!bh) {		put_page(page);		page = ERR_PTR(-ENOMEM);		goto out;	}	attach_page_buffers(page, bh);	block = index << (PAGE_SHIFT - inode->i_blkbits);	while (bh) {		if (count == 0)			bh->b_blocknr = 0;		else {			bh->b_blocknr = bmap(inode, block);			if (bh->b_blocknr == 0) {				/* Cannot use this file! */				free_buffers(page);				page = ERR_PTR(-EINVAL);				goto out;			}			bh->b_bdev = inode->i_sb->s_bdev;			if (count < (1<<inode->i_blkbits))				count = 0;			else				count -= (1<<inode->i_blkbits);			bh->b_end_io = end_bitmap_write;			bh->b_private = bitmap;			atomic_inc(&bitmap->pending_writes);			set_buffer_locked(bh);			set_buffer_mapped(bh);			submit_bh(READ, bh);		}		block++;		bh = bh->b_this_page;	}	page->index = index;	wait_event(bitmap->write_wait,		   atomic_read(&bitmap->pending_writes)==0);	if (bitmap->flags & BITMAP_WRITE_ERROR) {		free_buffers(page);		page = ERR_PTR(-EIO);	}out:	if (IS_ERR(page))		printk(KERN_ALERT "md: bitmap read error: (%dB @ %Lu): %ld/n",			(int)PAGE_SIZE,			(unsigned long long)index << PAGE_SHIFT,			PTR_ERR(page));	return page;}

int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr,			      sector_t pblocknr, int mode, int mode_flags,			      struct buffer_head **pbh, sector_t *submit_ptr){	struct buffer_head *bh;	struct inode *inode = NILFS_BTNC_I(btnc);	struct page *page;	int err;	bh = nilfs_grab_buffer(inode, btnc, blocknr, BIT(BH_NILFS_Node));	if (unlikely(!bh))		return -ENOMEM;	err = -EEXIST; /* internal code */	page = bh->b_page;	if (buffer_uptodate(bh) || buffer_dirty(bh))		goto found;	if (pblocknr == 0) {		pblocknr = blocknr;		if (inode->i_ino != NILFS_DAT_INO) {			struct the_nilfs *nilfs = inode->i_sb->s_fs_info;			/* blocknr is a virtual block number */			err = nilfs_dat_translate(nilfs->ns_dat, blocknr,						  &pblocknr);			if (unlikely(err)) {				brelse(bh);				goto out_locked;			}		}	}	if (mode_flags & REQ_RAHEAD) {		if (pblocknr != *submit_ptr + 1 || !trylock_buffer(bh)) {			err = -EBUSY; /* internal code */			brelse(bh);			goto out_locked;		}	} else { /* mode == READ */		lock_buffer(bh);	}	if (buffer_uptodate(bh)) {		unlock_buffer(bh);		err = -EEXIST; /* internal code */		goto found;	}	set_buffer_mapped(bh);	bh->b_bdev = inode->i_sb->s_bdev;	bh->b_blocknr = pblocknr; /* set block address for read */	bh->b_end_io = end_buffer_read_sync;	get_bh(bh);	submit_bh(mode, mode_flags, bh);	bh->b_blocknr = blocknr; /* set back to the given block address */	*submit_ptr = pblocknr;	err = 0;found:	*pbh = bh;out_locked:	unlock_page(page);	put_page(page);	return err;}

int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr,			      sector_t pblocknr, struct buffer_head **pbh,			      int newblk){	struct buffer_head *bh;	struct inode *inode = NILFS_BTNC_I(btnc);	int err;	btnode_debug(3, "called: blocknr=%llu pblocknr=%llu new=%d ino=%lu/n",		     (unsigned long long)blocknr, (unsigned long long)pblocknr,		     newblk, inode->i_ino);	bh = nilfs_grab_buffer(inode, btnc, blocknr, 1 << BH_NILFS_Node);	if (unlikely(!bh))		return -ENOMEM;	err = -EEXIST; /* internal code */	if (newblk) {		if (unlikely(buffer_mapped(bh) || buffer_uptodate(bh) ||			     buffer_dirty(bh))) {			BH_DEBUG(bh, "invalid new bh");			BUG();		}		bh->b_bdev = NILFS_I_NILFS(inode)->ns_bdev;		bh->b_blocknr = blocknr;		set_buffer_mapped(bh);		set_buffer_uptodate(bh);		goto found;	}	if (buffer_uptodate(bh) || buffer_dirty(bh))		goto found;	if (pblocknr == 0) {		pblocknr = blocknr;		if (inode->i_ino != NILFS_DAT_INO) {			struct inode *dat =				nilfs_dat_inode(NILFS_I_NILFS(inode));			/* blocknr is a virtual block number */			err = nilfs_dat_translate(dat, blocknr, &pblocknr);			if (unlikely(err)) {				brelse(bh);				btnode_debug(1, "return %d (xlate)./n", err);				goto out_locked;			}		}	}	lock_buffer(bh);	if (buffer_uptodate(bh)) {		unlock_buffer(bh);		err = -EEXIST; /* internal code */		goto found;	}	set_buffer_mapped(bh);	bh->b_bdev = NILFS_I_NILFS(inode)->ns_bdev;	bh->b_blocknr = pblocknr; /* set block address for read */	bh->b_end_io = end_buffer_read_sync;	get_bh(bh);	submit_bh(READ, bh);	bh->b_blocknr = blocknr; /* set back to the given block address */	err = 0;found:	*pbh = bh;out_locked:	unlock_page(bh->b_page);	page_cache_release(bh->b_page);	btnode_debug(3, "done (err=%d)/n", err);	return err;}