[linux-2.6-block.git] / fs / gfs2 / page.c

/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 * Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU General Public License v.2.
 */

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/pagemap.h>
#include <linux/mm.h>
#include <asm/semaphore.h>

#include "gfs2.h"
#include "bmap.h"
#include "inode.h"
#include "page.h"
#include "trans.h"
#include "ops_address.h"

/**
 * gfs2_pte_inval - Sync and invalidate all PTEs associated with a glock
 * @gl: the glock
 *
 */

void gfs2_pte_inval(struct gfs2_glock *gl)
{
	struct gfs2_inode *ip;
	struct inode *inode;

	ip = get_gl2ip(gl);
	if (!ip || !S_ISREG(ip->i_di.di_mode))
		return;

	if (!test_bit(GIF_PAGED, &ip->i_flags))
		return;

	inode = gfs2_ip2v_lookup(ip);
	if (inode) {
		unmap_shared_mapping_range(inode->i_mapping, 0, 0);
		iput(inode);

		if (test_bit(GIF_SW_PAGED, &ip->i_flags))
			set_bit(GLF_DIRTY, &gl->gl_flags);
	}

	clear_bit(GIF_SW_PAGED, &ip->i_flags);
}

/**
 * gfs2_page_inval - Invalidate all pages associated with a glock
 * @gl: the glock
 *
 */

void gfs2_page_inval(struct gfs2_glock *gl)
{
	struct gfs2_inode *ip;
	struct inode *inode;

	ip = get_gl2ip(gl);
	if (!ip || !S_ISREG(ip->i_di.di_mode))
		return;

	inode = gfs2_ip2v_lookup(ip);
	if (inode) {
		struct address_space *mapping = inode->i_mapping;

		truncate_inode_pages(mapping, 0);
		gfs2_assert_withdraw(ip->i_sbd, !mapping->nrpages);

		iput(inode);
	}

	clear_bit(GIF_PAGED, &ip->i_flags);
}

/**
 * gfs2_page_sync - Sync the data pages (not metadata) associated with a glock
 * @gl: the glock
 * @flags: DIO_START | DIO_WAIT
 *
 * Syncs data (not metadata) for a regular file.
 * No-op for all other types.
 */

void gfs2_page_sync(struct gfs2_glock *gl, int flags)
{
	struct gfs2_inode *ip;
	struct inode *inode;

	ip = get_gl2ip(gl);
	if (!ip || !S_ISREG(ip->i_di.di_mode))
		return;

	inode = gfs2_ip2v_lookup(ip);
	if (inode) {
		struct address_space *mapping = inode->i_mapping;
		int error = 0;

		if (flags & DIO_START)
			filemap_fdatawrite(mapping);
		if (!error && (flags & DIO_WAIT))
			error = filemap_fdatawait(mapping);

		/* Put back any errors cleared by filemap_fdatawait()
		   so they can be caught by someone who can pass them
		   up to user space. */

		if (error == -ENOSPC)
			set_bit(AS_ENOSPC, &mapping->flags);
		else if (error)
			set_bit(AS_EIO, &mapping->flags);

		iput(inode);
	}
}

/**
 * gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
 * @ip: the inode
 * @dibh: the dinode buffer
 * @block: the block number that was allocated
 * @private: any locked page held by the caller process
 *
 * Returns: errno
 */

int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,
			uint64_t block, void *private)
{
	struct gfs2_sbd *sdp = ip->i_sbd;
	struct inode *inode = ip->i_vnode;
	struct page *page = (struct page *)private;
	struct buffer_head *bh;
	int release = 0;

	if (!page || page->index) {
		page = grab_cache_page(inode->i_mapping, 0);
		if (!page)
			return -ENOMEM;
		release = 1;
	}

	if (!PageUptodate(page)) {
		void *kaddr = kmap(page);

		memcpy(kaddr,
		       dibh->b_data + sizeof(struct gfs2_dinode),
		       ip->i_di.di_size);
		memset(kaddr + ip->i_di.di_size,
		       0,
		       PAGE_CACHE_SIZE - ip->i_di.di_size);
		kunmap(page);

		SetPageUptodate(page);
	}

	if (!page_has_buffers(page))
		create_empty_buffers(page, 1 << inode->i_blkbits,
				     (1 << BH_Uptodate));

	bh = page_buffers(page);

	if (!buffer_mapped(bh))
		map_bh(bh, inode->i_sb, block);

	set_buffer_uptodate(bh);
	if ((sdp->sd_args.ar_data == GFS2_DATA_ORDERED) || gfs2_is_jdata(ip))
		gfs2_trans_add_bh(ip->i_gl, bh, 0);
	mark_buffer_dirty(bh);

	if (release) {
		unlock_page(page);
		page_cache_release(page);
	}

	return 0;
}

/**
 * gfs2_block_truncate_page - Deal with zeroing out data for truncate
 *
 * This is partly borrowed from ext3.
 */
int gfs2_block_truncate_page(struct address_space *mapping)
{
	struct inode *inode = mapping->host;
	struct gfs2_inode *ip = get_v2ip(inode);
	struct gfs2_sbd *sdp = ip->i_sbd;
	loff_t from = inode->i_size;
	unsigned long index = from >> PAGE_CACHE_SHIFT;
	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	unsigned blocksize, iblock, length, pos;
	struct buffer_head *bh;
	struct page *page;
	void *kaddr;
	int err;

	page = grab_cache_page(mapping, index);
	if (!page)
		return 0;

	blocksize = inode->i_sb->s_blocksize;
	length = blocksize - (offset & (blocksize - 1));
	iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);

	if (!page_has_buffers(page))
		create_empty_buffers(page, blocksize, 0);

	/* Find the buffer that contains "offset" */
	bh = page_buffers(page);
	pos = blocksize;
	while (offset >= pos) {
		bh = bh->b_this_page;
		iblock++;
		pos += blocksize;
	}

	err = 0;

	if (!buffer_mapped(bh)) {
		gfs2_get_block(inode, iblock, bh, 0);
		/* unmapped? It's a hole - nothing to do */
		if (!buffer_mapped(bh))
			goto unlock;
	}

	/* Ok, it's mapped. Make sure it's up-to-date */
	if (PageUptodate(page))
		set_buffer_uptodate(bh);

	if (!buffer_uptodate(bh)) {
		err = -EIO;
		ll_rw_block(READ, 1, &bh);
		wait_on_buffer(bh);
		/* Uhhuh. Read error. Complain and punt. */
		if (!buffer_uptodate(bh))
			goto unlock;
	}

	if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip))
		gfs2_trans_add_bh(ip->i_gl, bh, 0);

	kaddr = kmap_atomic(page, KM_USER0);
	memset(kaddr + offset, 0, length);
	flush_dcache_page(page);
	kunmap_atomic(kaddr, KM_USER0);

unlock:
	unlock_page(page);
	page_cache_release(page);
	return err;
}

void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,
			    unsigned int from, unsigned int to)
{
	struct buffer_head *head = page_buffers(page);
	unsigned int bsize = head->b_size;
	struct buffer_head *bh;
	unsigned int start, end;

	for (bh = head, start = 0;
	     bh != head || !start;
	     bh = bh->b_this_page, start = end) {
		end = start + bsize;
		if (end <= from || start >= to)
			continue;
		gfs2_trans_add_bh(ip->i_gl, bh, 0);
	}
}
Commit	Line	Data
b3b94faa DT	1	/*
	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
	3	* Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
	4	*
	5	* This copyrighted material is made available to anyone wishing to use,
	6	* modify, copy, or redistribute it subject to the terms and conditions
	7	* of the GNU General Public License v.2.
	8	*/
	9
	10	#include <linux/sched.h>
	11	#include <linux/slab.h>
	12	#include <linux/spinlock.h>
	13	#include <linux/completion.h>
	14	#include <linux/buffer_head.h>
	15	#include <linux/pagemap.h>
	16	#include <linux/mm.h>
	17	#include <asm/semaphore.h>
	18
	19	#include "gfs2.h"
	20	#include "bmap.h"
	21	#include "inode.h"
	22	#include "page.h"
	23	#include "trans.h"
257f9b4e	24	#include "ops_address.h"
b3b94faa DT	25
	26	/**
	27	* gfs2_pte_inval - Sync and invalidate all PTEs associated with a glock
	28	* @gl: the glock
	29	*
	30	*/
	31
	32	void gfs2_pte_inval(struct gfs2_glock *gl)
	33	{
	34	struct gfs2_inode *ip;
	35	struct inode *inode;
	36
	37	ip = get_gl2ip(gl);
	38	if (!ip \|\| !S_ISREG(ip->i_di.di_mode))
	39	return;
	40
	41	if (!test_bit(GIF_PAGED, &ip->i_flags))
	42	return;
	43
	44	inode = gfs2_ip2v_lookup(ip);
	45	if (inode) {
	46	unmap_shared_mapping_range(inode->i_mapping, 0, 0);
	47	iput(inode);
	48
	49	if (test_bit(GIF_SW_PAGED, &ip->i_flags))
	50	set_bit(GLF_DIRTY, &gl->gl_flags);
	51	}
	52
	53	clear_bit(GIF_SW_PAGED, &ip->i_flags);
	54	}
	55
	56	/**
	57	* gfs2_page_inval - Invalidate all pages associated with a glock
	58	* @gl: the glock
	59	*
	60	*/
	61
	62	void gfs2_page_inval(struct gfs2_glock *gl)
	63	{
	64	struct gfs2_inode *ip;
	65	struct inode *inode;
	66
	67	ip = get_gl2ip(gl);
	68	if (!ip \|\| !S_ISREG(ip->i_di.di_mode))
	69	return;
	70
	71	inode = gfs2_ip2v_lookup(ip);
	72	if (inode) {
	73	struct address_space *mapping = inode->i_mapping;
	74
	75	truncate_inode_pages(mapping, 0);
	76	gfs2_assert_withdraw(ip->i_sbd, !mapping->nrpages);
	77
	78	iput(inode);
	79	}
	80
	81	clear_bit(GIF_PAGED, &ip->i_flags);
	82	}
	83
	84	/**
	85	* gfs2_page_sync - Sync the data pages (not metadata) associated with a glock
	86	* @gl: the glock
	87	* @flags: DIO_START \| DIO_WAIT
	88	*
89	* Syncs data (not metadata) for a regular file.
90	* No-op for all other types.
91	*/
92
93	void gfs2_page_sync(struct gfs2_glock *gl, int flags)
94	{
95	struct gfs2_inode *ip;
96	struct inode *inode;
97
98	ip = get_gl2ip(gl);
99	if (!ip \|\| !S_ISREG(ip->i_di.di_mode))
100	return;
101
102	inode = gfs2_ip2v_lookup(ip);
103	if (inode) {
104	struct address_space *mapping = inode->i_mapping;
105	int error = 0;
106
107	if (flags & DIO_START)
108	filemap_fdatawrite(mapping);
109	if (!error && (flags & DIO_WAIT))
110	error = filemap_fdatawait(mapping);
111
112	/* Put back any errors cleared by filemap_fdatawait()
113	so they can be caught by someone who can pass them
114	up to user space. */
115
116	if (error == -ENOSPC)
117	set_bit(AS_ENOSPC, &mapping->flags);
118	else if (error)
119	set_bit(AS_EIO, &mapping->flags);
120
121	iput(inode);
122	}
123	}
124
125	/**
126	* gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
127	* @ip: the inode
128	* @dibh: the dinode buffer
129	* @block: the block number that was allocated
130	* @private: any locked page held by the caller process
131	*
132	* Returns: errno
133	*/
134
135	int gfs2_unstuffer_page(struct gfs2_inode ip, struct buffer_head dibh,
136	uint64_t block, void *private)
137	{
138	struct gfs2_sbd *sdp = ip->i_sbd;
139	struct inode *inode = ip->i_vnode;
140	struct page page = (struct page )private;
141	struct buffer_head *bh;
142	int release = 0;
143
144	if (!page \|\| page->index) {
145	page = grab_cache_page(inode->i_mapping, 0);
146	if (!page)
147	return -ENOMEM;
148	release = 1;
149	}
150
151	if (!PageUptodate(page)) {
152	void *kaddr = kmap(page);
153
154	memcpy(kaddr,
155	dibh->b_data + sizeof(struct gfs2_dinode),
156	ip->i_di.di_size);
157	memset(kaddr + ip->i_di.di_size,
158	0,
159	PAGE_CACHE_SIZE - ip->i_di.di_size);
160	kunmap(page);
161
162	SetPageUptodate(page);
163	}
164
165	if (!page_has_buffers(page))
166	create_empty_buffers(page, 1 << inode->i_blkbits,
167	(1 << BH_Uptodate));
168
169	bh = page_buffers(page);
170
171	if (!buffer_mapped(bh))
172	map_bh(bh, inode->i_sb, block);
173
174	set_buffer_uptodate(bh);
18ec7d5c SW	175	if ((sdp->sd_args.ar_data == GFS2_DATA_ORDERED) \|\| gfs2_is_jdata(ip))
18ec7d5c SW	176	gfs2_trans_add_bh(ip->i_gl, bh, 0);
b3b94faa DT	177	mark_buffer_dirty(bh);
	178
	179	if (release) {
	180	unlock_page(page);
	181	page_cache_release(page);
	182	}
	183
	184	return 0;
	185	}
	186
	187	/**
257f9b4e	188	* gfs2_block_truncate_page - Deal with zeroing out data for truncate
b3b94faa	189	*
257f9b4e	190	* This is partly borrowed from ext3.
b3b94faa	191	*/
257f9b4e	192	int gfs2_block_truncate_page(struct address_space *mapping)
b3b94faa	193	{
257f9b4e SW	194	struct inode *inode = mapping->host;
257f9b4e SW	195	struct gfs2_inode *ip = get_v2ip(inode);
b3b94faa	196	struct gfs2_sbd *sdp = ip->i_sbd;
257f9b4e SW	197	loff_t from = inode->i_size;
	198	unsigned long index = from >> PAGE_CACHE_SHIFT;
	199	unsigned offset = from & (PAGE_CACHE_SIZE-1);
	200	unsigned blocksize, iblock, length, pos;
b3b94faa	201	struct buffer_head *bh;
257f9b4e	202	struct page *page;
b3b94faa	203	void *kaddr;
257f9b4e SW	204	int err;
	205
	206	page = grab_cache_page(mapping, index);
	207	if (!page)
	208	return 0;
b3b94faa	209
257f9b4e SW	210	blocksize = inode->i_sb->s_blocksize;
	211	length = blocksize - (offset & (blocksize - 1));
	212	iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
b3b94faa DT	213
b3b94faa DT	214	if (!page_has_buffers(page))
257f9b4e	215	create_empty_buffers(page, blocksize, 0);
b3b94faa	216
257f9b4e SW	217	/* Find the buffer that contains "offset" */
	218	bh = page_buffers(page);
	219	pos = blocksize;
	220	while (offset >= pos) {
	221	bh = bh->b_this_page;
	222	iblock++;
	223	pos += blocksize;
	224	}
b3b94faa	225
257f9b4e	226	err = 0;
b3b94faa	227
257f9b4e SW	228	if (!buffer_mapped(bh)) {
	229	gfs2_get_block(inode, iblock, bh, 0);
	230	/* unmapped? It's a hole - nothing to do */
	231	if (!buffer_mapped(bh))
	232	goto unlock;
	233	}
	234
	235	/* Ok, it's mapped. Make sure it's up-to-date */
	236	if (PageUptodate(page))
	237	set_buffer_uptodate(bh);
	238
	239	if (!buffer_uptodate(bh)) {
	240	err = -EIO;
	241	ll_rw_block(READ, 1, &bh);
	242	wait_on_buffer(bh);
	243	/* Uhhuh. Read error. Complain and punt. */
	244	if (!buffer_uptodate(bh))
	245	goto unlock;
	246	}
	247
18ec7d5c SW	248	if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED \|\| gfs2_is_jdata(ip))
18ec7d5c SW	249	gfs2_trans_add_bh(ip->i_gl, bh, 0);
b3b94faa	250
257f9b4e SW	251	kaddr = kmap_atomic(page, KM_USER0);
	252	memset(kaddr + offset, 0, length);
	253	flush_dcache_page(page);
	254	kunmap_atomic(kaddr, KM_USER0);
	255
	256	unlock:
b3b94faa DT	257	unlock_page(page);
b3b94faa DT	258	page_cache_release(page);
257f9b4e	259	return err;
b3b94faa DT	260	}
b3b94faa DT	261
257f9b4e	262	void gfs2_page_add_databufs(struct gfs2_inode ip, struct page page,
b3b94faa DT	263	unsigned int from, unsigned int to)
	264	{
	265	struct buffer_head *head = page_buffers(page);
	266	unsigned int bsize = head->b_size;
	267	struct buffer_head *bh;
	268	unsigned int start, end;
	269
	270	for (bh = head, start = 0;
	271	bh != head \|\| !start;
	272	bh = bh->b_this_page, start = end) {
	273	end = start + bsize;
	274	if (end <= from \|\| start >= to)
	275	continue;
18ec7d5c	276	gfs2_trans_add_bh(ip->i_gl, bh, 0);
b3b94faa DT	277	}
	278	}
	279