}		}	} while (offset += len, p_offset += len,		((bh = bh->b_this_page) != head));	if (uptodate && bh == head)		SetPageUptodate(page);	if (startio)		xfs_submit_page(page, bh_arr, cnt);	if (iomp) {		tlast = (iomp->iomap_offset + iomp->iomap_bsize - 1) >>					PAGE_CACHE_SHIFT;		if (delalloc && (tlast > last_index))			tlast = last_index;		xfs_cluster_write(inode, page->index + 1, iomp, wbc,					startio, unmapped, tlast);	}	return page_dirty;error:	for (i = 0; i < cnt; i++) {		unlock_buffer(bh_arr[i]);	}	/*	 * If it's delalloc and we have nowhere to put it,	 * throw it away, unless the lower layers told	 * us to try again.	 */	if (err != -EAGAIN) {		if (!unmapped) {			block_invalidatepage(page, 0);		}		ClearPageUptodate(page);	}	return err;}STATIC intlinvfs_get_block_core(	struct inode		*inode,	sector_t		iblock,	unsigned long		blocks,	struct buffer_head	*bh_result,	int			create,	int			direct,	bmapi_flags_t		flags){	vnode_t			*vp = LINVFS_GET_VP(inode);	xfs_iomap_t		iomap;	int			retpbbm = 1;	int			error;	ssize_t			size;	loff_t			offset = (loff_t)iblock << inode->i_blkbits;	if (blocks)		size = blocks << inode->i_blkbits;	else		size = 1 << inode->i_blkbits;	VOP_BMAP(vp, offset, size,		create ? flags : BMAPI_READ, &iomap, &retpbbm, error);	if (error)		return -error;	if (retpbbm == 0)		return 0;	if (iomap.iomap_bn != IOMAP_DADDR_NULL) {		xfs_daddr_t		bn;		loff_t			delta;		/* For unwritten extents do not report a disk address on		 * the read case (treat as if we're reading into a hole).		 */		if (create || !(iomap.iomap_flags & IOMAP_UNWRITTEN)) {			delta = offset - iomap.iomap_offset;			delta >>= inode->i_blkbits;			bn = iomap.iomap_bn >> (inode->i_blkbits - BBSHIFT);			bn += delta;			bh_result->b_blocknr = bn;			bh_result->b_bdev = iomap.iomap_target->pbr_bdev;			set_buffer_mapped(bh_result);		}		if (create && (iomap.iomap_flags & IOMAP_UNWRITTEN)) {			if (direct)				bh_result->b_private = inode;			set_buffer_unwritten(bh_result);			set_buffer_delay(bh_result);		}	}	/* If this is a realtime file, data might be on a new device */	bh_result->b_bdev = iomap.iomap_target->pbr_bdev;	/* If we previously allocated a block out beyond eof and	 * we are now coming back to use it then we will need to	 * flag it as new even if it has a disk address.	 */	if (create &&	    ((!buffer_mapped(bh_result) && !buffer_uptodate(bh_result)) ||	     (offset >= i_size_read(inode)) || (iomap.iomap_flags & IOMAP_NEW))) {		set_buffer_new(bh_result);	}	if (iomap.iomap_flags & IOMAP_DELAY) {		if (unlikely(direct))			BUG();		if (create) {			set_buffer_mapped(bh_result);			set_buffer_uptodate(bh_result);		}		bh_result->b_bdev = iomap.iomap_target->pbr_bdev;		set_buffer_delay(bh_result);	}	if (blocks) {		loff_t iosize;		iosize = (iomap.iomap_bsize - iomap.iomap_delta);		bh_result->b_size =		    (ssize_t)min(iosize, (loff_t)(blocks << inode->i_blkbits));	}	return 0;}intlinvfs_get_block(	struct inode		*inode,	sector_t		iblock,	struct buffer_head	*bh_result,	int			create){	return linvfs_get_block_core(inode, iblock, 0, bh_result,					create, 0, BMAPI_WRITE);}STATIC intlinvfs_get_block_sync(	struct inode		*inode,	sector_t		iblock,	struct buffer_head	*bh_result,	int			create){	return linvfs_get_block_core(inode, iblock, 0, bh_result,					create, 0, BMAPI_SYNC|BMAPI_WRITE);}STATIC intlinvfs_get_blocks_direct(	struct inode		*inode,	sector_t		iblock,	unsigned long		max_blocks,	struct buffer_head	*bh_result,	int			create){	return linvfs_get_block_core(inode, iblock, max_blocks, bh_result,					create, 1, BMAPI_WRITE|BMAPI_DIRECT);}STATIC ssize_tlinvfs_direct_IO(	int			rw,	struct kiocb		*iocb,	const struct iovec	*iov,	loff_t			offset,	unsigned long		nr_segs){	struct file	*file = iocb->ki_filp;	struct inode	*inode = file->f_mapping->host;	vnode_t		*vp = LINVFS_GET_VP(inode);	xfs_iomap_t	iomap;	int		maps = 1;	int		error;	VOP_BMAP(vp, offset, 0, BMAPI_DEVICE, &iomap, &maps, error);	if (error)		return -error;	return blockdev_direct_IO_no_locking(rw, iocb, inode,		iomap.iomap_target->pbr_bdev,		iov, offset, nr_segs,		linvfs_get_blocks_direct,		linvfs_unwritten_convert_direct);}STATIC sector_tlinvfs_bmap(	struct address_space	*mapping,	sector_t		block){	struct inode		*inode = (struct inode *)mapping->host;	vnode_t			*vp = LINVFS_GET_VP(inode);	int			error;	vn_trace_entry(vp, "linvfs_bmap", (inst_t *)__return_address);	VOP_RWLOCK(vp, VRWLOCK_READ);	VOP_FLUSH_PAGES(vp, (xfs_off_t)0, -1, 0, FI_REMAPF, error);	VOP_RWUNLOCK(vp, VRWLOCK_READ);	return generic_block_bmap(mapping, block, linvfs_get_block);}STATIC intlinvfs_readpage(	struct file		*unused,	struct page		*page){	return mpage_readpage(page, linvfs_get_block);}STATIC intlinvfs_readpages(	struct file		*unused,	struct address_space	*mapping,	struct list_head	*pages,	unsigned		nr_pages){	return mpage_readpages(mapping, pages, nr_pages, linvfs_get_block);}STATIC voidxfs_count_page_state(	struct page		*page,	int			*delalloc,	int			*unmapped,	int			*unwritten){	struct buffer_head	*bh, *head;	*delalloc = *unmapped = *unwritten = 0;	bh = head = page_buffers(page);	do {		if (buffer_uptodate(bh) && !buffer_mapped(bh))			(*unmapped) = 1;		else if (buffer_unwritten(bh) && !buffer_delay(bh))			clear_buffer_unwritten(bh);		else if (buffer_unwritten(bh))			(*unwritten) = 1;		else if (buffer_delay(bh))			(*delalloc) = 1;	} while ((bh = bh->b_this_page) != head);}/* * writepage: Called from one of two places: * * 1. we are flushing a delalloc buffer head. * * 2. we are writing out a dirty page. Typically the page dirty *    state is cleared before we get here. In this case is it *    conceivable we have no buffer heads. * * For delalloc space on the page we need to allocate space and * flush it. For unmapped buffer heads on the page we should * allocate space if the page is uptodate. For any other dirty * buffer heads on the page we should flush them. * * If we detect that a transaction would be required to flush * the page, we have to check the process flags first, if we * are already in a transaction or disk I/O during allocations * is off, we need to fail the writepage and redirty the page. */STATIC intlinvfs_writepage(	struct page		*page,	struct writeback_control *wbc){	int			error;	int			need_trans;	int			delalloc, unmapped, unwritten;	struct inode		*inode = page->mapping->host;	xfs_page_trace(XFS_WRITEPAGE_ENTER, inode, page, 0);	/*	 * We need a transaction if:	 *  1. There are delalloc buffers on the page	 *  2. The page is uptodate and we have unmapped buffers	 *  3. The page is uptodate and we have no buffers	 *  4. There are unwritten buffers on the page	 */	if (!page_has_buffers(page)) {		unmapped = 1;		need_trans = 1;	} else {		xfs_count_page_state(page, &delalloc, &unmapped, &unwritten);		if (!PageUptodate(page))			unmapped = 0;		need_trans = delalloc + unmapped + unwritten;	}	/*	 * If we need a transaction and the process flags say	 * we are already in a transaction, or no IO is allowed	 * then mark the page dirty again and leave the page	 * as is.	 */	if (PFLAGS_TEST_FSTRANS() && need_trans)		goto out_fail;	/*	 * Delay hooking up buffer heads until we have	 * made our go/no-go decision.	 */	if (!page_has_buffers(page))		create_empty_buffers(page, 1 << inode->i_blkbits, 0);	/*	 * Convert delayed allocate, unwritten or unmapped space	 * to real space and flush out to disk.	 */	error = xfs_page_state_convert(inode, page, wbc, 1, unmapped);	if (error == -EAGAIN)		goto out_fail;	if (unlikely(error < 0))		goto out_unlock;	return 0;out_fail:	set_page_dirty(page);	unlock_page(page);	return 0;out_unlock:	unlock_page(page);	return error;}/* * Called to move a page into cleanable state - and from there * to be released. Possibly the page is already clean. We always * have buffer heads in this call. * * Returns 0 if the page is ok to release, 1 otherwise. * * Possible scenarios are: * * 1. We are being called to release a page which has been written *    to via regular I/O. buffer heads will be dirty and possibly *    delalloc. If no delalloc buffer heads in this case then we *    can just return zero. * * 2. We are called to release a page which has been written via *    mmap, all we need to do is ensure there is no delalloc *    state in the buffer heads, if not we can let the caller *    free them and we should come back later via writepage. */STATIC intlinvfs_release_page(	struct page		*page,	int			gfp_mask){	struct inode		*inode = page->mapping->host;	int			dirty, delalloc, unmapped, unwritten;	struct writeback_control wbc = {		.sync_mode = WB_SYNC_ALL,		.nr_to_write = 1,	};	xfs_page_trace(XFS_RELEASEPAGE_ENTER, inode, page, gfp_mask);	xfs_count_page_state(page, &delalloc, &unmapped, &unwritten);	if (!delalloc && !unwritten)		goto free_buffers;	if (!(gfp_mask & __GFP_FS))		return 0;	/* If we are already inside a transaction or the thread cannot	 * do I/O, we cannot release this page.	 */	if (PFLAGS_TEST_FSTRANS())		return 0;	/*	 * Convert delalloc space to real space, do not flush the	 * data out to disk, that will be done by the caller.	 * Never need to allocate space here - we will always	 * come back to writepage in that case.	 */	dirty = xfs_page_state_convert(inode, page, &wbc, 0, 0);	if (dirty == 0 && !unwritten)		goto free_buffers;	return 0;free_buffers:	return try_to_free_buffers(page);}STATIC intlinvfs_prepare_write(	struct file		*file,	struct page		*page,	unsigned int		from,	unsigned int		to){	if (file && (file->f_flags & O_SYNC)) {		return block_prepare_write(page, from, to,						linvfs_get_block_sync);	} else {		return block_prepare_write(page, from, to,						linvfs_get_block);	}}struct address_space_operations linvfs_aops = {	.readpage		= linvfs_readpage,	.readpages		= linvfs_readpages,	.writepage		= linvfs_writepage,	.sync_page		= block_sync_page,	.releasepage		= linvfs_release_page,	.prepare_write		= linvfs_prepare_write,	.commit_write		= generic_commit_write,	.bmap			= linvfs_bmap,	.direct_IO		= linvfs_direct_IO,};