Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 9dbe9610b9df4efe0946299804ed46bb8f91dec2

Authored by Steven Whitehouse 2012-10-31 18:37:10 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

GFS2: Add Orlov allocator

Just like ext3, this works on the root directory and any directory
with the +T flag set. Also, just like ext3, any subdirectory created
in one of the just mentioned cases will be allocated to a random
resource group (GFS2 equivalent of a block group).

If you are creating a set of directories, each of which will contain a
job running on a different node, then by setting +T on the parent
directory before creating the subdirectories, each will land up in a
different resource group, and thus resource group contention between
nodes will be kept to a minimum.

Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

Showing 8 changed files with 38 additions and 15 deletions Inline Diff

fs/gfs2/aops.c
fs/gfs2/bmap.c
fs/gfs2/file.c
fs/gfs2/inode.c
fs/gfs2/quota.c
fs/gfs2/rgrp.c
fs/gfs2/rgrp.h
fs/gfs2/xattr.c

fs/gfs2/aops.c

Diff comments View file @ 9dbe961

1	/*	1	/*
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.	3	* Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
4	*	4	*
5	* This copyrighted material is made available to anyone wishing to use,	5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions	6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.	7	* of the GNU General Public License version 2.
8	*/	8	*/
9		9
10	#include <linux/sched.h>	10	#include <linux/sched.h>
11	#include <linux/slab.h>	11	#include <linux/slab.h>
12	#include <linux/spinlock.h>	12	#include <linux/spinlock.h>
13	#include <linux/completion.h>	13	#include <linux/completion.h>
14	#include <linux/buffer_head.h>	14	#include <linux/buffer_head.h>
15	#include <linux/pagemap.h>	15	#include <linux/pagemap.h>
16	#include <linux/pagevec.h>	16	#include <linux/pagevec.h>
17	#include <linux/mpage.h>	17	#include <linux/mpage.h>
18	#include <linux/fs.h>	18	#include <linux/fs.h>
19	#include <linux/writeback.h>	19	#include <linux/writeback.h>
20	#include <linux/swap.h>	20	#include <linux/swap.h>
21	#include <linux/gfs2_ondisk.h>	21	#include <linux/gfs2_ondisk.h>
22	#include <linux/backing-dev.h>	22	#include <linux/backing-dev.h>
23		23
24	#include "gfs2.h"	24	#include "gfs2.h"
25	#include "incore.h"	25	#include "incore.h"
26	#include "bmap.h"	26	#include "bmap.h"
27	#include "glock.h"	27	#include "glock.h"
28	#include "inode.h"	28	#include "inode.h"
29	#include "log.h"	29	#include "log.h"
30	#include "meta_io.h"	30	#include "meta_io.h"
31	#include "quota.h"	31	#include "quota.h"
32	#include "trans.h"	32	#include "trans.h"
33	#include "rgrp.h"	33	#include "rgrp.h"
34	#include "super.h"	34	#include "super.h"
35	#include "util.h"	35	#include "util.h"
36	#include "glops.h"	36	#include "glops.h"
37		37
38		38
39	static void gfs2_page_add_databufs(struct gfs2_inode ip, struct page page,	39	static void gfs2_page_add_databufs(struct gfs2_inode ip, struct page page,
40	unsigned int from, unsigned int to)	40	unsigned int from, unsigned int to)
41	{	41	{
42	struct buffer_head *head = page_buffers(page);	42	struct buffer_head *head = page_buffers(page);
43	unsigned int bsize = head->b_size;	43	unsigned int bsize = head->b_size;
44	struct buffer_head *bh;	44	struct buffer_head *bh;
45	unsigned int start, end;	45	unsigned int start, end;
46		46
47	for (bh = head, start = 0; bh != head \|\| !start;	47	for (bh = head, start = 0; bh != head \|\| !start;
48	bh = bh->b_this_page, start = end) {	48	bh = bh->b_this_page, start = end) {
49	end = start + bsize;	49	end = start + bsize;
50	if (end <= from \|\| start >= to)	50	if (end <= from \|\| start >= to)
51	continue;	51	continue;
52	if (gfs2_is_jdata(ip))	52	if (gfs2_is_jdata(ip))
53	set_buffer_uptodate(bh);	53	set_buffer_uptodate(bh);
54	gfs2_trans_add_bh(ip->i_gl, bh, 0);	54	gfs2_trans_add_bh(ip->i_gl, bh, 0);
55	}	55	}
56	}	56	}
57		57
58	/**	58	/**
59	* gfs2_get_block_noalloc - Fills in a buffer head with details about a block	59	* gfs2_get_block_noalloc - Fills in a buffer head with details about a block
60	* @inode: The inode	60	* @inode: The inode
61	* @lblock: The block number to look up	61	* @lblock: The block number to look up
62	* @bh_result: The buffer head to return the result in	62	* @bh_result: The buffer head to return the result in
63	* @create: Non-zero if we may add block to the file	63	* @create: Non-zero if we may add block to the file
64	*	64	*
65	* Returns: errno	65	* Returns: errno
66	*/	66	*/
67		67
68	static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,	68	static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,
69	struct buffer_head *bh_result, int create)	69	struct buffer_head *bh_result, int create)
70	{	70	{
71	int error;	71	int error;
72		72
73	error = gfs2_block_map(inode, lblock, bh_result, 0);	73	error = gfs2_block_map(inode, lblock, bh_result, 0);
74	if (error)	74	if (error)
75	return error;	75	return error;
76	if (!buffer_mapped(bh_result))	76	if (!buffer_mapped(bh_result))
77	return -EIO;	77	return -EIO;
78	return 0;	78	return 0;
79	}	79	}
80		80
81	static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,	81	static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,
82	struct buffer_head *bh_result, int create)	82	struct buffer_head *bh_result, int create)
83	{	83	{
84	return gfs2_block_map(inode, lblock, bh_result, 0);	84	return gfs2_block_map(inode, lblock, bh_result, 0);
85	}	85	}
86		86
87	/**	87	/**
88	* gfs2_writepage_common - Common bits of writepage	88	* gfs2_writepage_common - Common bits of writepage
89	* @page: The page to be written	89	* @page: The page to be written
90	* @wbc: The writeback control	90	* @wbc: The writeback control
91	*	91	*
92	* Returns: 1 if writepage is ok, otherwise an error code or zero if no error.	92	* Returns: 1 if writepage is ok, otherwise an error code or zero if no error.
93	*/	93	*/
94		94
95	static int gfs2_writepage_common(struct page *page,	95	static int gfs2_writepage_common(struct page *page,
96	struct writeback_control *wbc)	96	struct writeback_control *wbc)
97	{	97	{
98	struct inode *inode = page->mapping->host;	98	struct inode *inode = page->mapping->host;
99	struct gfs2_inode *ip = GFS2_I(inode);	99	struct gfs2_inode *ip = GFS2_I(inode);
100	struct gfs2_sbd *sdp = GFS2_SB(inode);	100	struct gfs2_sbd *sdp = GFS2_SB(inode);
101	loff_t i_size = i_size_read(inode);	101	loff_t i_size = i_size_read(inode);
102	pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;	102	pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
103	unsigned offset;	103	unsigned offset;
104		104
105	if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl)))	105	if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl)))
106	goto out;	106	goto out;
107	if (current->journal_info)	107	if (current->journal_info)
108	goto redirty;	108	goto redirty;
109	/* Is the page fully outside i_size? (truncate in progress) */	109	/* Is the page fully outside i_size? (truncate in progress) */
110	offset = i_size & (PAGE_CACHE_SIZE-1);	110	offset = i_size & (PAGE_CACHE_SIZE-1);
111	if (page->index > end_index \|\| (page->index == end_index && !offset)) {	111	if (page->index > end_index \|\| (page->index == end_index && !offset)) {
112	page->mapping->a_ops->invalidatepage(page, 0);	112	page->mapping->a_ops->invalidatepage(page, 0);
113	goto out;	113	goto out;
114	}	114	}
115	return 1;	115	return 1;
116	redirty:	116	redirty:
117	redirty_page_for_writepage(wbc, page);	117	redirty_page_for_writepage(wbc, page);
118	out:	118	out:
119	unlock_page(page);	119	unlock_page(page);
120	return 0;	120	return 0;
121	}	121	}
122		122
123	/**	123	/**
124	* gfs2_writeback_writepage - Write page for writeback mappings	124	* gfs2_writeback_writepage - Write page for writeback mappings
125	* @page: The page	125	* @page: The page
126	* @wbc: The writeback control	126	* @wbc: The writeback control
127	*	127	*
128	*/	128	*/
129		129
130	static int gfs2_writeback_writepage(struct page *page,	130	static int gfs2_writeback_writepage(struct page *page,
131	struct writeback_control *wbc)	131	struct writeback_control *wbc)
132	{	132	{
133	int ret;	133	int ret;
134		134
135	ret = gfs2_writepage_common(page, wbc);	135	ret = gfs2_writepage_common(page, wbc);
136	if (ret <= 0)	136	if (ret <= 0)
137	return ret;	137	return ret;
138		138
139	return nobh_writepage(page, gfs2_get_block_noalloc, wbc);	139	return nobh_writepage(page, gfs2_get_block_noalloc, wbc);
140	}	140	}
141		141
142	/**	142	/**
143	* gfs2_ordered_writepage - Write page for ordered data files	143	* gfs2_ordered_writepage - Write page for ordered data files
144	* @page: The page to write	144	* @page: The page to write
145	* @wbc: The writeback control	145	* @wbc: The writeback control
146	*	146	*
147	*/	147	*/
148		148
149	static int gfs2_ordered_writepage(struct page *page,	149	static int gfs2_ordered_writepage(struct page *page,
150	struct writeback_control *wbc)	150	struct writeback_control *wbc)
151	{	151	{
152	struct inode *inode = page->mapping->host;	152	struct inode *inode = page->mapping->host;
153	struct gfs2_inode *ip = GFS2_I(inode);	153	struct gfs2_inode *ip = GFS2_I(inode);
154	int ret;	154	int ret;
155		155
156	ret = gfs2_writepage_common(page, wbc);	156	ret = gfs2_writepage_common(page, wbc);
157	if (ret <= 0)	157	if (ret <= 0)
158	return ret;	158	return ret;
159		159
160	if (!page_has_buffers(page)) {	160	if (!page_has_buffers(page)) {
161	create_empty_buffers(page, inode->i_sb->s_blocksize,	161	create_empty_buffers(page, inode->i_sb->s_blocksize,
162	(1 << BH_Dirty)\|(1 << BH_Uptodate));	162	(1 << BH_Dirty)\|(1 << BH_Uptodate));
163	}	163	}
164	gfs2_page_add_databufs(ip, page, 0, inode->i_sb->s_blocksize-1);	164	gfs2_page_add_databufs(ip, page, 0, inode->i_sb->s_blocksize-1);
165	return block_write_full_page(page, gfs2_get_block_noalloc, wbc);	165	return block_write_full_page(page, gfs2_get_block_noalloc, wbc);
166	}	166	}
167		167
168	/**	168	/**
169	* __gfs2_jdata_writepage - The core of jdata writepage	169	* __gfs2_jdata_writepage - The core of jdata writepage
170	* @page: The page to write	170	* @page: The page to write
171	* @wbc: The writeback control	171	* @wbc: The writeback control
172	*	172	*
173	* This is shared between writepage and writepages and implements the	173	* This is shared between writepage and writepages and implements the
174	* core of the writepage operation. If a transaction is required then	174	* core of the writepage operation. If a transaction is required then
175	* PageChecked will have been set and the transaction will have	175	* PageChecked will have been set and the transaction will have
176	* already been started before this is called.	176	* already been started before this is called.
177	*/	177	*/
178		178
179	static int __gfs2_jdata_writepage(struct page page, struct writeback_control wbc)	179	static int __gfs2_jdata_writepage(struct page page, struct writeback_control wbc)
180	{	180	{
181	struct inode *inode = page->mapping->host;	181	struct inode *inode = page->mapping->host;
182	struct gfs2_inode *ip = GFS2_I(inode);	182	struct gfs2_inode *ip = GFS2_I(inode);
183	struct gfs2_sbd *sdp = GFS2_SB(inode);	183	struct gfs2_sbd *sdp = GFS2_SB(inode);
184		184
185	if (PageChecked(page)) {	185	if (PageChecked(page)) {
186	ClearPageChecked(page);	186	ClearPageChecked(page);
187	if (!page_has_buffers(page)) {	187	if (!page_has_buffers(page)) {
188	create_empty_buffers(page, inode->i_sb->s_blocksize,	188	create_empty_buffers(page, inode->i_sb->s_blocksize,
189	(1 << BH_Dirty)\|(1 << BH_Uptodate));	189	(1 << BH_Dirty)\|(1 << BH_Uptodate));
190	}	190	}
191	gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);	191	gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
192	}	192	}
193	return block_write_full_page(page, gfs2_get_block_noalloc, wbc);	193	return block_write_full_page(page, gfs2_get_block_noalloc, wbc);
194	}	194	}
195		195
196	/**	196	/**
197	* gfs2_jdata_writepage - Write complete page	197	* gfs2_jdata_writepage - Write complete page
198	* @page: Page to write	198	* @page: Page to write
199	*	199	*
200	* Returns: errno	200	* Returns: errno
201	*	201	*
202	*/	202	*/
203		203
204	static int gfs2_jdata_writepage(struct page page, struct writeback_control wbc)	204	static int gfs2_jdata_writepage(struct page page, struct writeback_control wbc)
205	{	205	{
206	struct inode *inode = page->mapping->host;	206	struct inode *inode = page->mapping->host;
207	struct gfs2_sbd *sdp = GFS2_SB(inode);	207	struct gfs2_sbd *sdp = GFS2_SB(inode);
208	int ret;	208	int ret;
209	int done_trans = 0;	209	int done_trans = 0;
210		210
211	if (PageChecked(page)) {	211	if (PageChecked(page)) {
212	if (wbc->sync_mode != WB_SYNC_ALL)	212	if (wbc->sync_mode != WB_SYNC_ALL)
213	goto out_ignore;	213	goto out_ignore;
214	ret = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);	214	ret = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
215	if (ret)	215	if (ret)
216	goto out_ignore;	216	goto out_ignore;
217	done_trans = 1;	217	done_trans = 1;
218	}	218	}
219	ret = gfs2_writepage_common(page, wbc);	219	ret = gfs2_writepage_common(page, wbc);
220	if (ret > 0)	220	if (ret > 0)
221	ret = __gfs2_jdata_writepage(page, wbc);	221	ret = __gfs2_jdata_writepage(page, wbc);
222	if (done_trans)	222	if (done_trans)
223	gfs2_trans_end(sdp);	223	gfs2_trans_end(sdp);
224	return ret;	224	return ret;
225		225
226	out_ignore:	226	out_ignore:
227	redirty_page_for_writepage(wbc, page);	227	redirty_page_for_writepage(wbc, page);
228	unlock_page(page);	228	unlock_page(page);
229	return 0;	229	return 0;
230	}	230	}
231		231
232	/**	232	/**
233	* gfs2_writeback_writepages - Write a bunch of dirty pages back to disk	233	* gfs2_writeback_writepages - Write a bunch of dirty pages back to disk
234	* @mapping: The mapping to write	234	* @mapping: The mapping to write
235	* @wbc: Write-back control	235	* @wbc: Write-back control
236	*	236	*
237	* For the data=writeback case we can already ignore buffer heads	237	* For the data=writeback case we can already ignore buffer heads
238	* and write whole extents at once. This is a big reduction in the	238	* and write whole extents at once. This is a big reduction in the
239	* number of I/O requests we send and the bmap calls we make in this case.	239	* number of I/O requests we send and the bmap calls we make in this case.
240	*/	240	*/
241	static int gfs2_writeback_writepages(struct address_space *mapping,	241	static int gfs2_writeback_writepages(struct address_space *mapping,
242	struct writeback_control *wbc)	242	struct writeback_control *wbc)
243	{	243	{
244	return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc);	244	return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc);
245	}	245	}
246		246
247	/**	247	/**
248	* gfs2_write_jdata_pagevec - Write back a pagevec's worth of pages	248	* gfs2_write_jdata_pagevec - Write back a pagevec's worth of pages
249	* @mapping: The mapping	249	* @mapping: The mapping
250	* @wbc: The writeback control	250	* @wbc: The writeback control
251	* @writepage: The writepage function to call for each page	251	* @writepage: The writepage function to call for each page
252	* @pvec: The vector of pages	252	* @pvec: The vector of pages
253	* @nr_pages: The number of pages to write	253	* @nr_pages: The number of pages to write
254	*	254	*
255	* Returns: non-zero if loop should terminate, zero otherwise	255	* Returns: non-zero if loop should terminate, zero otherwise
256	*/	256	*/
257		257
258	static int gfs2_write_jdata_pagevec(struct address_space *mapping,	258	static int gfs2_write_jdata_pagevec(struct address_space *mapping,
259	struct writeback_control *wbc,	259	struct writeback_control *wbc,
260	struct pagevec *pvec,	260	struct pagevec *pvec,
261	int nr_pages, pgoff_t end)	261	int nr_pages, pgoff_t end)
262	{	262	{
263	struct inode *inode = mapping->host;	263	struct inode *inode = mapping->host;
264	struct gfs2_sbd *sdp = GFS2_SB(inode);	264	struct gfs2_sbd *sdp = GFS2_SB(inode);
265	loff_t i_size = i_size_read(inode);	265	loff_t i_size = i_size_read(inode);
266	pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;	266	pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
267	unsigned offset = i_size & (PAGE_CACHE_SIZE-1);	267	unsigned offset = i_size & (PAGE_CACHE_SIZE-1);
268	unsigned nrblocks = nr_pages * (PAGE_CACHE_SIZE/inode->i_sb->s_blocksize);	268	unsigned nrblocks = nr_pages * (PAGE_CACHE_SIZE/inode->i_sb->s_blocksize);
269	int i;	269	int i;
270	int ret;	270	int ret;
271		271
272	ret = gfs2_trans_begin(sdp, nrblocks, nrblocks);	272	ret = gfs2_trans_begin(sdp, nrblocks, nrblocks);
273	if (ret < 0)	273	if (ret < 0)
274	return ret;	274	return ret;
275		275
276	for(i = 0; i < nr_pages; i++) {	276	for(i = 0; i < nr_pages; i++) {
277	struct page *page = pvec->pages[i];	277	struct page *page = pvec->pages[i];
278		278
279	lock_page(page);	279	lock_page(page);
280		280
281	if (unlikely(page->mapping != mapping)) {	281	if (unlikely(page->mapping != mapping)) {
282	unlock_page(page);	282	unlock_page(page);
283	continue;	283	continue;
284	}	284	}
285		285
286	if (!wbc->range_cyclic && page->index > end) {	286	if (!wbc->range_cyclic && page->index > end) {
287	ret = 1;	287	ret = 1;
288	unlock_page(page);	288	unlock_page(page);
289	continue;	289	continue;
290	}	290	}
291		291
292	if (wbc->sync_mode != WB_SYNC_NONE)	292	if (wbc->sync_mode != WB_SYNC_NONE)
293	wait_on_page_writeback(page);	293	wait_on_page_writeback(page);
294		294
295	if (PageWriteback(page) \|\|	295	if (PageWriteback(page) \|\|
296	!clear_page_dirty_for_io(page)) {	296	!clear_page_dirty_for_io(page)) {
297	unlock_page(page);	297	unlock_page(page);
298	continue;	298	continue;
299	}	299	}
300		300
301	/* Is the page fully outside i_size? (truncate in progress) */	301	/* Is the page fully outside i_size? (truncate in progress) */
302	if (page->index > end_index \|\| (page->index == end_index && !offset)) {	302	if (page->index > end_index \|\| (page->index == end_index && !offset)) {
303	page->mapping->a_ops->invalidatepage(page, 0);	303	page->mapping->a_ops->invalidatepage(page, 0);
304	unlock_page(page);	304	unlock_page(page);
305	continue;	305	continue;
306	}	306	}
307		307
308	ret = __gfs2_jdata_writepage(page, wbc);	308	ret = __gfs2_jdata_writepage(page, wbc);
309		309
310	if (ret \|\| (--(wbc->nr_to_write) <= 0))	310	if (ret \|\| (--(wbc->nr_to_write) <= 0))
311	ret = 1;	311	ret = 1;
312	}	312	}
313	gfs2_trans_end(sdp);	313	gfs2_trans_end(sdp);
314	return ret;	314	return ret;
315	}	315	}
316		316
317	/**	317	/**
318	* gfs2_write_cache_jdata - Like write_cache_pages but different	318	* gfs2_write_cache_jdata - Like write_cache_pages but different
319	* @mapping: The mapping to write	319	* @mapping: The mapping to write
320	* @wbc: The writeback control	320	* @wbc: The writeback control
321	* @writepage: The writepage function to call	321	* @writepage: The writepage function to call
322	* @data: The data to pass to writepage	322	* @data: The data to pass to writepage
323	*	323	*
324	* The reason that we use our own function here is that we need to	324	* The reason that we use our own function here is that we need to
325	* start transactions before we grab page locks. This allows us	325	* start transactions before we grab page locks. This allows us
326	* to get the ordering right.	326	* to get the ordering right.
327	*/	327	*/
328		328
329	static int gfs2_write_cache_jdata(struct address_space *mapping,	329	static int gfs2_write_cache_jdata(struct address_space *mapping,
330	struct writeback_control *wbc)	330	struct writeback_control *wbc)
331	{	331	{
332	int ret = 0;	332	int ret = 0;
333	int done = 0;	333	int done = 0;
334	struct pagevec pvec;	334	struct pagevec pvec;
335	int nr_pages;	335	int nr_pages;
336	pgoff_t index;	336	pgoff_t index;
337	pgoff_t end;	337	pgoff_t end;
338	int scanned = 0;	338	int scanned = 0;
339	int range_whole = 0;	339	int range_whole = 0;
340		340
341	pagevec_init(&pvec, 0);	341	pagevec_init(&pvec, 0);
342	if (wbc->range_cyclic) {	342	if (wbc->range_cyclic) {
343	index = mapping->writeback_index; /* Start from prev offset */	343	index = mapping->writeback_index; /* Start from prev offset */
344	end = -1;	344	end = -1;
345	} else {	345	} else {
346	index = wbc->range_start >> PAGE_CACHE_SHIFT;	346	index = wbc->range_start >> PAGE_CACHE_SHIFT;
347	end = wbc->range_end >> PAGE_CACHE_SHIFT;	347	end = wbc->range_end >> PAGE_CACHE_SHIFT;
348	if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)	348	if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
349	range_whole = 1;	349	range_whole = 1;
350	scanned = 1;	350	scanned = 1;
351	}	351	}
352		352
353	retry:	353	retry:
354	while (!done && (index <= end) &&	354	while (!done && (index <= end) &&
355	(nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,	355	(nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
356	PAGECACHE_TAG_DIRTY,	356	PAGECACHE_TAG_DIRTY,
357	min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1))) {	357	min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1))) {
358	scanned = 1;	358	scanned = 1;
359	ret = gfs2_write_jdata_pagevec(mapping, wbc, &pvec, nr_pages, end);	359	ret = gfs2_write_jdata_pagevec(mapping, wbc, &pvec, nr_pages, end);
360	if (ret)	360	if (ret)
361	done = 1;	361	done = 1;
362	if (ret > 0)	362	if (ret > 0)
363	ret = 0;	363	ret = 0;
364		364
365	pagevec_release(&pvec);	365	pagevec_release(&pvec);
366	cond_resched();	366	cond_resched();
367	}	367	}
368		368
369	if (!scanned && !done) {	369	if (!scanned && !done) {
370	/*	370	/*
371	* We hit the last page and there is more work to be done: wrap	371	* We hit the last page and there is more work to be done: wrap
372	* back to the start of the file	372	* back to the start of the file
373	*/	373	*/
374	scanned = 1;	374	scanned = 1;
375	index = 0;	375	index = 0;
376	goto retry;	376	goto retry;
377	}	377	}
378		378
379	if (wbc->range_cyclic \|\| (range_whole && wbc->nr_to_write > 0))	379	if (wbc->range_cyclic \|\| (range_whole && wbc->nr_to_write > 0))
380	mapping->writeback_index = index;	380	mapping->writeback_index = index;
381	return ret;	381	return ret;
382	}	382	}
383		383
384		384
385	/**	385	/**
386	* gfs2_jdata_writepages - Write a bunch of dirty pages back to disk	386	* gfs2_jdata_writepages - Write a bunch of dirty pages back to disk
387	* @mapping: The mapping to write	387	* @mapping: The mapping to write
388	* @wbc: The writeback control	388	* @wbc: The writeback control
389	*	389	*
390	*/	390	*/
391		391
392	static int gfs2_jdata_writepages(struct address_space *mapping,	392	static int gfs2_jdata_writepages(struct address_space *mapping,
393	struct writeback_control *wbc)	393	struct writeback_control *wbc)
394	{	394	{
395	struct gfs2_inode *ip = GFS2_I(mapping->host);	395	struct gfs2_inode *ip = GFS2_I(mapping->host);
396	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);	396	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);
397	int ret;	397	int ret;
398		398
399	ret = gfs2_write_cache_jdata(mapping, wbc);	399	ret = gfs2_write_cache_jdata(mapping, wbc);
400	if (ret == 0 && wbc->sync_mode == WB_SYNC_ALL) {	400	if (ret == 0 && wbc->sync_mode == WB_SYNC_ALL) {
401	gfs2_log_flush(sdp, ip->i_gl);	401	gfs2_log_flush(sdp, ip->i_gl);
402	ret = gfs2_write_cache_jdata(mapping, wbc);	402	ret = gfs2_write_cache_jdata(mapping, wbc);
403	}	403	}
404	return ret;	404	return ret;
405	}	405	}
406		406
407	/**	407	/**
408	* stuffed_readpage - Fill in a Linux page with stuffed file data	408	* stuffed_readpage - Fill in a Linux page with stuffed file data
409	* @ip: the inode	409	* @ip: the inode
410	* @page: the page	410	* @page: the page
411	*	411	*
412	* Returns: errno	412	* Returns: errno
413	*/	413	*/
414		414
415	static int stuffed_readpage(struct gfs2_inode ip, struct page page)	415	static int stuffed_readpage(struct gfs2_inode ip, struct page page)
416	{	416	{
417	struct buffer_head *dibh;	417	struct buffer_head *dibh;
418	u64 dsize = i_size_read(&ip->i_inode);	418	u64 dsize = i_size_read(&ip->i_inode);
419	void *kaddr;	419	void *kaddr;
420	int error;	420	int error;
421		421
422	/*	422	/*
423	* Due to the order of unstuffing files and ->fault(), we can be	423	* Due to the order of unstuffing files and ->fault(), we can be
424	* asked for a zero page in the case of a stuffed file being extended,	424	* asked for a zero page in the case of a stuffed file being extended,
425	* so we need to supply one here. It doesn't happen often.	425	* so we need to supply one here. It doesn't happen often.
426	*/	426	*/
427	if (unlikely(page->index)) {	427	if (unlikely(page->index)) {
428	zero_user(page, 0, PAGE_CACHE_SIZE);	428	zero_user(page, 0, PAGE_CACHE_SIZE);
429	SetPageUptodate(page);	429	SetPageUptodate(page);
430	return 0;	430	return 0;
431	}	431	}
432		432
433	error = gfs2_meta_inode_buffer(ip, &dibh);	433	error = gfs2_meta_inode_buffer(ip, &dibh);
434	if (error)	434	if (error)
435	return error;	435	return error;
436		436
437	kaddr = kmap_atomic(page);	437	kaddr = kmap_atomic(page);
438	if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode)))	438	if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode)))
439	dsize = (dibh->b_size - sizeof(struct gfs2_dinode));	439	dsize = (dibh->b_size - sizeof(struct gfs2_dinode));
440	memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);	440	memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
441	memset(kaddr + dsize, 0, PAGE_CACHE_SIZE - dsize);	441	memset(kaddr + dsize, 0, PAGE_CACHE_SIZE - dsize);
442	kunmap_atomic(kaddr);	442	kunmap_atomic(kaddr);
443	flush_dcache_page(page);	443	flush_dcache_page(page);
444	brelse(dibh);	444	brelse(dibh);
445	SetPageUptodate(page);	445	SetPageUptodate(page);
446		446
447	return 0;	447	return 0;
448	}	448	}
449		449
450		450
451	/**	451	/**
452	* __gfs2_readpage - readpage	452	* __gfs2_readpage - readpage
453	* @file: The file to read a page for	453	* @file: The file to read a page for
454	* @page: The page to read	454	* @page: The page to read
455	*	455	*
456	* This is the core of gfs2's readpage. Its used by the internal file	456	* This is the core of gfs2's readpage. Its used by the internal file
457	* reading code as in that case we already hold the glock. Also its	457	* reading code as in that case we already hold the glock. Also its
458	* called by gfs2_readpage() once the required lock has been granted.	458	* called by gfs2_readpage() once the required lock has been granted.
459	*	459	*
460	*/	460	*/
461		461
462	static int __gfs2_readpage(void file, struct page page)	462	static int __gfs2_readpage(void file, struct page page)
463	{	463	{
464	struct gfs2_inode *ip = GFS2_I(page->mapping->host);	464	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
465	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);	465	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
466	int error;	466	int error;
467		467
468	if (gfs2_is_stuffed(ip)) {	468	if (gfs2_is_stuffed(ip)) {
469	error = stuffed_readpage(ip, page);	469	error = stuffed_readpage(ip, page);
470	unlock_page(page);	470	unlock_page(page);
471	} else {	471	} else {
472	error = mpage_readpage(page, gfs2_block_map);	472	error = mpage_readpage(page, gfs2_block_map);
473	}	473	}
474		474
475	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))	475	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
476	return -EIO;	476	return -EIO;
477		477
478	return error;	478	return error;
479	}	479	}
480		480
481	/**	481	/**
482	* gfs2_readpage - read a page of a file	482	* gfs2_readpage - read a page of a file
483	* @file: The file to read	483	* @file: The file to read
484	* @page: The page of the file	484	* @page: The page of the file
485	*	485	*
486	* This deals with the locking required. We have to unlock and	486	* This deals with the locking required. We have to unlock and
487	* relock the page in order to get the locking in the right	487	* relock the page in order to get the locking in the right
488	* order.	488	* order.
489	*/	489	*/
490		490
491	static int gfs2_readpage(struct file file, struct page page)	491	static int gfs2_readpage(struct file file, struct page page)
492	{	492	{
493	struct address_space *mapping = page->mapping;	493	struct address_space *mapping = page->mapping;
494	struct gfs2_inode *ip = GFS2_I(mapping->host);	494	struct gfs2_inode *ip = GFS2_I(mapping->host);
495	struct gfs2_holder gh;	495	struct gfs2_holder gh;
496	int error;	496	int error;
497		497
498	unlock_page(page);	498	unlock_page(page);
499	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);	499	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
500	error = gfs2_glock_nq(&gh);	500	error = gfs2_glock_nq(&gh);
501	if (unlikely(error))	501	if (unlikely(error))
502	goto out;	502	goto out;
503	error = AOP_TRUNCATED_PAGE;	503	error = AOP_TRUNCATED_PAGE;
504	lock_page(page);	504	lock_page(page);
505	if (page->mapping == mapping && !PageUptodate(page))	505	if (page->mapping == mapping && !PageUptodate(page))
506	error = __gfs2_readpage(file, page);	506	error = __gfs2_readpage(file, page);
507	else	507	else
508	unlock_page(page);	508	unlock_page(page);
509	gfs2_glock_dq(&gh);	509	gfs2_glock_dq(&gh);
510	out:	510	out:
511	gfs2_holder_uninit(&gh);	511	gfs2_holder_uninit(&gh);
512	if (error && error != AOP_TRUNCATED_PAGE)	512	if (error && error != AOP_TRUNCATED_PAGE)
513	lock_page(page);	513	lock_page(page);
514	return error;	514	return error;
515	}	515	}
516		516
517	/**	517	/**
518	* gfs2_internal_read - read an internal file	518	* gfs2_internal_read - read an internal file
519	* @ip: The gfs2 inode	519	* @ip: The gfs2 inode
520	* @buf: The buffer to fill	520	* @buf: The buffer to fill
521	* @pos: The file position	521	* @pos: The file position
522	* @size: The amount to read	522	* @size: The amount to read
523	*	523	*
524	*/	524	*/
525		525
526	int gfs2_internal_read(struct gfs2_inode ip, char buf, loff_t *pos,	526	int gfs2_internal_read(struct gfs2_inode ip, char buf, loff_t *pos,
527	unsigned size)	527	unsigned size)
528	{	528	{
529	struct address_space *mapping = ip->i_inode.i_mapping;	529	struct address_space *mapping = ip->i_inode.i_mapping;
530	unsigned long index = *pos / PAGE_CACHE_SIZE;	530	unsigned long index = *pos / PAGE_CACHE_SIZE;
531	unsigned offset = *pos & (PAGE_CACHE_SIZE - 1);	531	unsigned offset = *pos & (PAGE_CACHE_SIZE - 1);
532	unsigned copied = 0;	532	unsigned copied = 0;
533	unsigned amt;	533	unsigned amt;
534	struct page *page;	534	struct page *page;
535	void *p;	535	void *p;
536		536
537	do {	537	do {
538	amt = size - copied;	538	amt = size - copied;
539	if (offset + size > PAGE_CACHE_SIZE)	539	if (offset + size > PAGE_CACHE_SIZE)
540	amt = PAGE_CACHE_SIZE - offset;	540	amt = PAGE_CACHE_SIZE - offset;
541	page = read_cache_page(mapping, index, __gfs2_readpage, NULL);	541	page = read_cache_page(mapping, index, __gfs2_readpage, NULL);
542	if (IS_ERR(page))	542	if (IS_ERR(page))
543	return PTR_ERR(page);	543	return PTR_ERR(page);
544	p = kmap_atomic(page);	544	p = kmap_atomic(page);
545	memcpy(buf + copied, p + offset, amt);	545	memcpy(buf + copied, p + offset, amt);
546	kunmap_atomic(p);	546	kunmap_atomic(p);
547	mark_page_accessed(page);	547	mark_page_accessed(page);
548	page_cache_release(page);	548	page_cache_release(page);
549	copied += amt;	549	copied += amt;
550	index++;	550	index++;
551	offset = 0;	551	offset = 0;
552	} while(copied < size);	552	} while(copied < size);
553	(*pos) += size;	553	(*pos) += size;
554	return size;	554	return size;
555	}	555	}
556		556
557	/**	557	/**
558	* gfs2_readpages - Read a bunch of pages at once	558	* gfs2_readpages - Read a bunch of pages at once
559	*	559	*
560	* Some notes:	560	* Some notes:
561	* 1. This is only for readahead, so we can simply ignore any things	561	* 1. This is only for readahead, so we can simply ignore any things
562	* which are slightly inconvenient (such as locking conflicts between	562	* which are slightly inconvenient (such as locking conflicts between
563	* the page lock and the glock) and return having done no I/O. Its	563	* the page lock and the glock) and return having done no I/O. Its
564	* obviously not something we'd want to do on too regular a basis.	564	* obviously not something we'd want to do on too regular a basis.
565	* Any I/O we ignore at this time will be done via readpage later.	565	* Any I/O we ignore at this time will be done via readpage later.
566	* 2. We don't handle stuffed files here we let readpage do the honours.	566	* 2. We don't handle stuffed files here we let readpage do the honours.
567	* 3. mpage_readpages() does most of the heavy lifting in the common case.	567	* 3. mpage_readpages() does most of the heavy lifting in the common case.
568	* 4. gfs2_block_map() is relied upon to set BH_Boundary in the right places.	568	* 4. gfs2_block_map() is relied upon to set BH_Boundary in the right places.
569	*/	569	*/
570		570
571	static int gfs2_readpages(struct file file, struct address_space mapping,	571	static int gfs2_readpages(struct file file, struct address_space mapping,
572	struct list_head *pages, unsigned nr_pages)	572	struct list_head *pages, unsigned nr_pages)
573	{	573	{
574	struct inode *inode = mapping->host;	574	struct inode *inode = mapping->host;
575	struct gfs2_inode *ip = GFS2_I(inode);	575	struct gfs2_inode *ip = GFS2_I(inode);
576	struct gfs2_sbd *sdp = GFS2_SB(inode);	576	struct gfs2_sbd *sdp = GFS2_SB(inode);
577	struct gfs2_holder gh;	577	struct gfs2_holder gh;
578	int ret;	578	int ret;
579		579
580	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);	580	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
581	ret = gfs2_glock_nq(&gh);	581	ret = gfs2_glock_nq(&gh);
582	if (unlikely(ret))	582	if (unlikely(ret))
583	goto out_uninit;	583	goto out_uninit;
584	if (!gfs2_is_stuffed(ip))	584	if (!gfs2_is_stuffed(ip))
585	ret = mpage_readpages(mapping, pages, nr_pages, gfs2_block_map);	585	ret = mpage_readpages(mapping, pages, nr_pages, gfs2_block_map);
586	gfs2_glock_dq(&gh);	586	gfs2_glock_dq(&gh);
587	out_uninit:	587	out_uninit:
588	gfs2_holder_uninit(&gh);	588	gfs2_holder_uninit(&gh);
589	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))	589	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
590	ret = -EIO;	590	ret = -EIO;
591	return ret;	591	return ret;
592	}	592	}
593		593
594	/**	594	/**
595	* gfs2_write_begin - Begin to write to a file	595	* gfs2_write_begin - Begin to write to a file
596	* @file: The file to write to	596	* @file: The file to write to
597	* @mapping: The mapping in which to write	597	* @mapping: The mapping in which to write
598	* @pos: The file offset at which to start writing	598	* @pos: The file offset at which to start writing
599	* @len: Length of the write	599	* @len: Length of the write
600	* @flags: Various flags	600	* @flags: Various flags
601	* @pagep: Pointer to return the page	601	* @pagep: Pointer to return the page
602	* @fsdata: Pointer to return fs data (unused by GFS2)	602	* @fsdata: Pointer to return fs data (unused by GFS2)
603	*	603	*
604	* Returns: errno	604	* Returns: errno
605	*/	605	*/
606		606
607	static int gfs2_write_begin(struct file file, struct address_space mapping,	607	static int gfs2_write_begin(struct file file, struct address_space mapping,
608	loff_t pos, unsigned len, unsigned flags,	608	loff_t pos, unsigned len, unsigned flags,
609	struct page pagep, void fsdata)	609	struct page pagep, void fsdata)
610	{	610	{
611	struct gfs2_inode *ip = GFS2_I(mapping->host);	611	struct gfs2_inode *ip = GFS2_I(mapping->host);
612	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);	612	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);
613	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);	613	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
614	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;	614	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
615	unsigned requested = 0;	615	unsigned requested = 0;
616	int alloc_required;	616	int alloc_required;
617	int error = 0;	617	int error = 0;
618	pgoff_t index = pos >> PAGE_CACHE_SHIFT;	618	pgoff_t index = pos >> PAGE_CACHE_SHIFT;
619	unsigned from = pos & (PAGE_CACHE_SIZE - 1);	619	unsigned from = pos & (PAGE_CACHE_SIZE - 1);
620	struct page *page;	620	struct page *page;
621		621
622	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);	622	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
623	error = gfs2_glock_nq(&ip->i_gh);	623	error = gfs2_glock_nq(&ip->i_gh);
624	if (unlikely(error))	624	if (unlikely(error))
625	goto out_uninit;	625	goto out_uninit;
626	if (&ip->i_inode == sdp->sd_rindex) {	626	if (&ip->i_inode == sdp->sd_rindex) {
627	error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,	627	error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE,
628	GL_NOCACHE, &m_ip->i_gh);	628	GL_NOCACHE, &m_ip->i_gh);
629	if (unlikely(error)) {	629	if (unlikely(error)) {
630	gfs2_glock_dq(&ip->i_gh);	630	gfs2_glock_dq(&ip->i_gh);
631	goto out_uninit;	631	goto out_uninit;
632	}	632	}
633	}	633	}
634		634
635	alloc_required = gfs2_write_alloc_required(ip, pos, len);	635	alloc_required = gfs2_write_alloc_required(ip, pos, len);
636		636
637	if (alloc_required \|\| gfs2_is_jdata(ip))	637	if (alloc_required \|\| gfs2_is_jdata(ip))
638	gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks);	638	gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks);
639		639
640	if (alloc_required) {	640	if (alloc_required) {
641	error = gfs2_quota_lock_check(ip);	641	error = gfs2_quota_lock_check(ip);
642	if (error)	642	if (error)
643	goto out_unlock;	643	goto out_unlock;
644		644
645	requested = data_blocks + ind_blocks;	645	requested = data_blocks + ind_blocks;
646	error = gfs2_inplace_reserve(ip, requested);	646	error = gfs2_inplace_reserve(ip, requested, 0);
647	if (error)	647	if (error)
648	goto out_qunlock;	648	goto out_qunlock;
649	}	649	}
650		650
651	rblocks = RES_DINODE + ind_blocks;	651	rblocks = RES_DINODE + ind_blocks;
652	if (gfs2_is_jdata(ip))	652	if (gfs2_is_jdata(ip))
653	rblocks += data_blocks ? data_blocks : 1;	653	rblocks += data_blocks ? data_blocks : 1;
654	if (ind_blocks \|\| data_blocks)	654	if (ind_blocks \|\| data_blocks)
655	rblocks += RES_STATFS + RES_QUOTA;	655	rblocks += RES_STATFS + RES_QUOTA;
656	if (&ip->i_inode == sdp->sd_rindex)	656	if (&ip->i_inode == sdp->sd_rindex)
657	rblocks += 2 * RES_STATFS;	657	rblocks += 2 * RES_STATFS;
658	if (alloc_required)	658	if (alloc_required)
659	rblocks += gfs2_rg_blocks(ip, requested);	659	rblocks += gfs2_rg_blocks(ip, requested);
660		660
661	error = gfs2_trans_begin(sdp, rblocks,	661	error = gfs2_trans_begin(sdp, rblocks,
662	PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);	662	PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
663	if (error)	663	if (error)
664	goto out_trans_fail;	664	goto out_trans_fail;
665		665
666	error = -ENOMEM;	666	error = -ENOMEM;
667	flags \|= AOP_FLAG_NOFS;	667	flags \|= AOP_FLAG_NOFS;
668	page = grab_cache_page_write_begin(mapping, index, flags);	668	page = grab_cache_page_write_begin(mapping, index, flags);
669	*pagep = page;	669	*pagep = page;
670	if (unlikely(!page))	670	if (unlikely(!page))
671	goto out_endtrans;	671	goto out_endtrans;
672		672
673	if (gfs2_is_stuffed(ip)) {	673	if (gfs2_is_stuffed(ip)) {
674	error = 0;	674	error = 0;
675	if (pos + len > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {	675	if (pos + len > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
676	error = gfs2_unstuff_dinode(ip, page);	676	error = gfs2_unstuff_dinode(ip, page);
677	if (error == 0)	677	if (error == 0)
678	goto prepare_write;	678	goto prepare_write;
679	} else if (!PageUptodate(page)) {	679	} else if (!PageUptodate(page)) {
680	error = stuffed_readpage(ip, page);	680	error = stuffed_readpage(ip, page);
681	}	681	}
682	goto out;	682	goto out;
683	}	683	}
684		684
685	prepare_write:	685	prepare_write:
686	error = __block_write_begin(page, from, len, gfs2_block_map);	686	error = __block_write_begin(page, from, len, gfs2_block_map);
687	out:	687	out:
688	if (error == 0)	688	if (error == 0)
689	return 0;	689	return 0;
690		690
691	unlock_page(page);	691	unlock_page(page);
692	page_cache_release(page);	692	page_cache_release(page);
693		693
694	gfs2_trans_end(sdp);	694	gfs2_trans_end(sdp);
695	if (pos + len > ip->i_inode.i_size)	695	if (pos + len > ip->i_inode.i_size)
696	gfs2_trim_blocks(&ip->i_inode);	696	gfs2_trim_blocks(&ip->i_inode);
697	goto out_trans_fail;	697	goto out_trans_fail;
698		698
699	out_endtrans:	699	out_endtrans:
700	gfs2_trans_end(sdp);	700	gfs2_trans_end(sdp);
701	out_trans_fail:	701	out_trans_fail:
702	if (alloc_required) {	702	if (alloc_required) {
703	gfs2_inplace_release(ip);	703	gfs2_inplace_release(ip);
704	out_qunlock:	704	out_qunlock:
705	gfs2_quota_unlock(ip);	705	gfs2_quota_unlock(ip);
706	}	706	}
707	out_unlock:	707	out_unlock:
708	if (&ip->i_inode == sdp->sd_rindex) {	708	if (&ip->i_inode == sdp->sd_rindex) {
709	gfs2_glock_dq(&m_ip->i_gh);	709	gfs2_glock_dq(&m_ip->i_gh);
710	gfs2_holder_uninit(&m_ip->i_gh);	710	gfs2_holder_uninit(&m_ip->i_gh);
711	}	711	}
712	gfs2_glock_dq(&ip->i_gh);	712	gfs2_glock_dq(&ip->i_gh);
713	out_uninit:	713	out_uninit:
714	gfs2_holder_uninit(&ip->i_gh);	714	gfs2_holder_uninit(&ip->i_gh);
715	return error;	715	return error;
716	}	716	}
717		717
718	/**	718	/**
719	* adjust_fs_space - Adjusts the free space available due to gfs2_grow	719	* adjust_fs_space - Adjusts the free space available due to gfs2_grow
720	* @inode: the rindex inode	720	* @inode: the rindex inode
721	*/	721	*/
722	static void adjust_fs_space(struct inode *inode)	722	static void adjust_fs_space(struct inode *inode)
723	{	723	{
724	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;	724	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
725	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);	725	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
726	struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);	726	struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
727	struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;	727	struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
728	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;	728	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
729	struct buffer_head m_bh, l_bh;	729	struct buffer_head m_bh, l_bh;
730	u64 fs_total, new_free;	730	u64 fs_total, new_free;
731		731
732	/* Total up the file system space, according to the latest rindex. */	732	/* Total up the file system space, according to the latest rindex. */
733	fs_total = gfs2_ri_total(sdp);	733	fs_total = gfs2_ri_total(sdp);
734	if (gfs2_meta_inode_buffer(m_ip, &m_bh) != 0)	734	if (gfs2_meta_inode_buffer(m_ip, &m_bh) != 0)
735	return;	735	return;
736		736
737	spin_lock(&sdp->sd_statfs_spin);	737	spin_lock(&sdp->sd_statfs_spin);
738	gfs2_statfs_change_in(m_sc, m_bh->b_data +	738	gfs2_statfs_change_in(m_sc, m_bh->b_data +
739	sizeof(struct gfs2_dinode));	739	sizeof(struct gfs2_dinode));
740	if (fs_total > (m_sc->sc_total + l_sc->sc_total))	740	if (fs_total > (m_sc->sc_total + l_sc->sc_total))
741	new_free = fs_total - (m_sc->sc_total + l_sc->sc_total);	741	new_free = fs_total - (m_sc->sc_total + l_sc->sc_total);
742	else	742	else
743	new_free = 0;	743	new_free = 0;
744	spin_unlock(&sdp->sd_statfs_spin);	744	spin_unlock(&sdp->sd_statfs_spin);
745	fs_warn(sdp, "File system extended by %llu blocks.\n",	745	fs_warn(sdp, "File system extended by %llu blocks.\n",
746	(unsigned long long)new_free);	746	(unsigned long long)new_free);
747	gfs2_statfs_change(sdp, new_free, new_free, 0);	747	gfs2_statfs_change(sdp, new_free, new_free, 0);
748		748
749	if (gfs2_meta_inode_buffer(l_ip, &l_bh) != 0)	749	if (gfs2_meta_inode_buffer(l_ip, &l_bh) != 0)
750	goto out;	750	goto out;
751	update_statfs(sdp, m_bh, l_bh);	751	update_statfs(sdp, m_bh, l_bh);
752	brelse(l_bh);	752	brelse(l_bh);
753	out:	753	out:
754	brelse(m_bh);	754	brelse(m_bh);
755	}	755	}
756		756
757	/**	757	/**
758	* gfs2_stuffed_write_end - Write end for stuffed files	758	* gfs2_stuffed_write_end - Write end for stuffed files
759	* @inode: The inode	759	* @inode: The inode
760	* @dibh: The buffer_head containing the on-disk inode	760	* @dibh: The buffer_head containing the on-disk inode
761	* @pos: The file position	761	* @pos: The file position
762	* @len: The length of the write	762	* @len: The length of the write
763	* @copied: How much was actually copied by the VFS	763	* @copied: How much was actually copied by the VFS
764	* @page: The page	764	* @page: The page
765	*	765	*
766	* This copies the data from the page into the inode block after	766	* This copies the data from the page into the inode block after
767	* the inode data structure itself.	767	* the inode data structure itself.
768	*	768	*
769	* Returns: errno	769	* Returns: errno
770	*/	770	*/
771	static int gfs2_stuffed_write_end(struct inode inode, struct buffer_head dibh,	771	static int gfs2_stuffed_write_end(struct inode inode, struct buffer_head dibh,
772	loff_t pos, unsigned len, unsigned copied,	772	loff_t pos, unsigned len, unsigned copied,
773	struct page *page)	773	struct page *page)
774	{	774	{
775	struct gfs2_inode *ip = GFS2_I(inode);	775	struct gfs2_inode *ip = GFS2_I(inode);
776	struct gfs2_sbd *sdp = GFS2_SB(inode);	776	struct gfs2_sbd *sdp = GFS2_SB(inode);
777	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);	777	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
778	u64 to = pos + copied;	778	u64 to = pos + copied;
779	void *kaddr;	779	void *kaddr;
780	unsigned char *buf = dibh->b_data + sizeof(struct gfs2_dinode);	780	unsigned char *buf = dibh->b_data + sizeof(struct gfs2_dinode);
781		781
782	BUG_ON((pos + len) > (dibh->b_size - sizeof(struct gfs2_dinode)));	782	BUG_ON((pos + len) > (dibh->b_size - sizeof(struct gfs2_dinode)));
783	kaddr = kmap_atomic(page);	783	kaddr = kmap_atomic(page);
784	memcpy(buf + pos, kaddr + pos, copied);	784	memcpy(buf + pos, kaddr + pos, copied);
785	memset(kaddr + pos + copied, 0, len - copied);	785	memset(kaddr + pos + copied, 0, len - copied);
786	flush_dcache_page(page);	786	flush_dcache_page(page);
787	kunmap_atomic(kaddr);	787	kunmap_atomic(kaddr);
788		788
789	if (!PageUptodate(page))	789	if (!PageUptodate(page))
790	SetPageUptodate(page);	790	SetPageUptodate(page);
791	unlock_page(page);	791	unlock_page(page);
792	page_cache_release(page);	792	page_cache_release(page);
793		793
794	if (copied) {	794	if (copied) {
795	if (inode->i_size < to)	795	if (inode->i_size < to)
796	i_size_write(inode, to);	796	i_size_write(inode, to);
797	mark_inode_dirty(inode);	797	mark_inode_dirty(inode);
798	}	798	}
799		799
800	if (inode == sdp->sd_rindex) {	800	if (inode == sdp->sd_rindex) {
801	adjust_fs_space(inode);	801	adjust_fs_space(inode);
802	sdp->sd_rindex_uptodate = 0;	802	sdp->sd_rindex_uptodate = 0;
803	}	803	}
804		804
805	brelse(dibh);	805	brelse(dibh);
806	gfs2_trans_end(sdp);	806	gfs2_trans_end(sdp);
807	if (inode == sdp->sd_rindex) {	807	if (inode == sdp->sd_rindex) {
808	gfs2_glock_dq(&m_ip->i_gh);	808	gfs2_glock_dq(&m_ip->i_gh);
809	gfs2_holder_uninit(&m_ip->i_gh);	809	gfs2_holder_uninit(&m_ip->i_gh);
810	}	810	}
811	gfs2_glock_dq(&ip->i_gh);	811	gfs2_glock_dq(&ip->i_gh);
812	gfs2_holder_uninit(&ip->i_gh);	812	gfs2_holder_uninit(&ip->i_gh);
813	return copied;	813	return copied;
814	}	814	}
815		815
816	/**	816	/**
817	* gfs2_write_end	817	* gfs2_write_end
818	* @file: The file to write to	818	* @file: The file to write to
819	* @mapping: The address space to write to	819	* @mapping: The address space to write to
820	* @pos: The file position	820	* @pos: The file position
821	* @len: The length of the data	821	* @len: The length of the data
822	* @copied:	822	* @copied:
823	* @page: The page that has been written	823	* @page: The page that has been written
824	* @fsdata: The fsdata (unused in GFS2)	824	* @fsdata: The fsdata (unused in GFS2)
825	*	825	*
826	* The main write_end function for GFS2. We have a separate one for	826	* The main write_end function for GFS2. We have a separate one for
827	* stuffed files as they are slightly different, otherwise we just	827	* stuffed files as they are slightly different, otherwise we just
828	* put our locking around the VFS provided functions.	828	* put our locking around the VFS provided functions.
829	*	829	*
830	* Returns: errno	830	* Returns: errno
831	*/	831	*/
832		832
833	static int gfs2_write_end(struct file file, struct address_space mapping,	833	static int gfs2_write_end(struct file file, struct address_space mapping,
834	loff_t pos, unsigned len, unsigned copied,	834	loff_t pos, unsigned len, unsigned copied,
835	struct page page, void fsdata)	835	struct page page, void fsdata)
836	{	836	{
837	struct inode *inode = page->mapping->host;	837	struct inode *inode = page->mapping->host;
838	struct gfs2_inode *ip = GFS2_I(inode);	838	struct gfs2_inode *ip = GFS2_I(inode);
839	struct gfs2_sbd *sdp = GFS2_SB(inode);	839	struct gfs2_sbd *sdp = GFS2_SB(inode);
840	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);	840	struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
841	struct buffer_head *dibh;	841	struct buffer_head *dibh;
842	unsigned int from = pos & (PAGE_CACHE_SIZE - 1);	842	unsigned int from = pos & (PAGE_CACHE_SIZE - 1);
843	unsigned int to = from + len;	843	unsigned int to = from + len;
844	int ret;	844	int ret;
845		845
846	BUG_ON(gfs2_glock_is_locked_by_me(ip->i_gl) == NULL);	846	BUG_ON(gfs2_glock_is_locked_by_me(ip->i_gl) == NULL);
847		847
848	ret = gfs2_meta_inode_buffer(ip, &dibh);	848	ret = gfs2_meta_inode_buffer(ip, &dibh);
849	if (unlikely(ret)) {	849	if (unlikely(ret)) {
850	unlock_page(page);	850	unlock_page(page);
851	page_cache_release(page);	851	page_cache_release(page);
852	goto failed;	852	goto failed;
853	}	853	}
854		854
855	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	855	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
856		856
857	if (gfs2_is_stuffed(ip))	857	if (gfs2_is_stuffed(ip))
858	return gfs2_stuffed_write_end(inode, dibh, pos, len, copied, page);	858	return gfs2_stuffed_write_end(inode, dibh, pos, len, copied, page);
859		859
860	if (!gfs2_is_writeback(ip))	860	if (!gfs2_is_writeback(ip))
861	gfs2_page_add_databufs(ip, page, from, to);	861	gfs2_page_add_databufs(ip, page, from, to);
862		862
863	ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);	863	ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
864		864
865	if (inode == sdp->sd_rindex) {	865	if (inode == sdp->sd_rindex) {
866	adjust_fs_space(inode);	866	adjust_fs_space(inode);
867	sdp->sd_rindex_uptodate = 0;	867	sdp->sd_rindex_uptodate = 0;
868	}	868	}
869		869
870	brelse(dibh);	870	brelse(dibh);
871	failed:	871	failed:
872	gfs2_trans_end(sdp);	872	gfs2_trans_end(sdp);
873	gfs2_inplace_release(ip);	873	gfs2_inplace_release(ip);
874	if (ip->i_res->rs_qa_qd_num)	874	if (ip->i_res->rs_qa_qd_num)
875	gfs2_quota_unlock(ip);	875	gfs2_quota_unlock(ip);
876	if (inode == sdp->sd_rindex) {	876	if (inode == sdp->sd_rindex) {
877	gfs2_glock_dq(&m_ip->i_gh);	877	gfs2_glock_dq(&m_ip->i_gh);
878	gfs2_holder_uninit(&m_ip->i_gh);	878	gfs2_holder_uninit(&m_ip->i_gh);
879	}	879	}
880	gfs2_glock_dq(&ip->i_gh);	880	gfs2_glock_dq(&ip->i_gh);
881	gfs2_holder_uninit(&ip->i_gh);	881	gfs2_holder_uninit(&ip->i_gh);
882	return ret;	882	return ret;
883	}	883	}
884		884
885	/**	885	/**
886	* gfs2_set_page_dirty - Page dirtying function	886	* gfs2_set_page_dirty - Page dirtying function
887	* @page: The page to dirty	887	* @page: The page to dirty
888	*	888	*
889	* Returns: 1 if it dirtyed the page, or 0 otherwise	889	* Returns: 1 if it dirtyed the page, or 0 otherwise
890	*/	890	*/
891		891
892	static int gfs2_set_page_dirty(struct page *page)	892	static int gfs2_set_page_dirty(struct page *page)
893	{	893	{
894	SetPageChecked(page);	894	SetPageChecked(page);
895	return __set_page_dirty_buffers(page);	895	return __set_page_dirty_buffers(page);
896	}	896	}
897		897
898	/**	898	/**
899	* gfs2_bmap - Block map function	899	* gfs2_bmap - Block map function
900	* @mapping: Address space info	900	* @mapping: Address space info
901	* @lblock: The block to map	901	* @lblock: The block to map
902	*	902	*
903	* Returns: The disk address for the block or 0 on hole or error	903	* Returns: The disk address for the block or 0 on hole or error
904	*/	904	*/
905		905
906	static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)	906	static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)
907	{	907	{
908	struct gfs2_inode *ip = GFS2_I(mapping->host);	908	struct gfs2_inode *ip = GFS2_I(mapping->host);
909	struct gfs2_holder i_gh;	909	struct gfs2_holder i_gh;
910	sector_t dblock = 0;	910	sector_t dblock = 0;
911	int error;	911	int error;
912		912
913	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);	913	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
914	if (error)	914	if (error)
915	return 0;	915	return 0;
916		916
917	if (!gfs2_is_stuffed(ip))	917	if (!gfs2_is_stuffed(ip))
918	dblock = generic_block_bmap(mapping, lblock, gfs2_block_map);	918	dblock = generic_block_bmap(mapping, lblock, gfs2_block_map);
919		919
920	gfs2_glock_dq_uninit(&i_gh);	920	gfs2_glock_dq_uninit(&i_gh);
921		921
922	return dblock;	922	return dblock;
923	}	923	}
924		924
925	static void gfs2_discard(struct gfs2_sbd sdp, struct buffer_head bh)	925	static void gfs2_discard(struct gfs2_sbd sdp, struct buffer_head bh)
926	{	926	{
927	struct gfs2_bufdata *bd;	927	struct gfs2_bufdata *bd;
928		928
929	lock_buffer(bh);	929	lock_buffer(bh);
930	gfs2_log_lock(sdp);	930	gfs2_log_lock(sdp);
931	clear_buffer_dirty(bh);	931	clear_buffer_dirty(bh);
932	bd = bh->b_private;	932	bd = bh->b_private;
933	if (bd) {	933	if (bd) {
934	if (!list_empty(&bd->bd_list) && !buffer_pinned(bh))	934	if (!list_empty(&bd->bd_list) && !buffer_pinned(bh))
935	list_del_init(&bd->bd_list);	935	list_del_init(&bd->bd_list);
936	else	936	else
937	gfs2_remove_from_journal(bh, current->journal_info, 0);	937	gfs2_remove_from_journal(bh, current->journal_info, 0);
938	}	938	}
939	bh->b_bdev = NULL;	939	bh->b_bdev = NULL;
940	clear_buffer_mapped(bh);	940	clear_buffer_mapped(bh);
941	clear_buffer_req(bh);	941	clear_buffer_req(bh);
942	clear_buffer_new(bh);	942	clear_buffer_new(bh);
943	gfs2_log_unlock(sdp);	943	gfs2_log_unlock(sdp);
944	unlock_buffer(bh);	944	unlock_buffer(bh);
945	}	945	}
946		946
947	static void gfs2_invalidatepage(struct page *page, unsigned long offset)	947	static void gfs2_invalidatepage(struct page *page, unsigned long offset)
948	{	948	{
949	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);	949	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
950	struct buffer_head bh, head;	950	struct buffer_head bh, head;
951	unsigned long pos = 0;	951	unsigned long pos = 0;
952		952
953	BUG_ON(!PageLocked(page));	953	BUG_ON(!PageLocked(page));
954	if (offset == 0)	954	if (offset == 0)
955	ClearPageChecked(page);	955	ClearPageChecked(page);
956	if (!page_has_buffers(page))	956	if (!page_has_buffers(page))
957	goto out;	957	goto out;
958		958
959	bh = head = page_buffers(page);	959	bh = head = page_buffers(page);
960	do {	960	do {
961	if (offset <= pos)	961	if (offset <= pos)
962	gfs2_discard(sdp, bh);	962	gfs2_discard(sdp, bh);
963	pos += bh->b_size;	963	pos += bh->b_size;
964	bh = bh->b_this_page;	964	bh = bh->b_this_page;
965	} while (bh != head);	965	} while (bh != head);
966	out:	966	out:
967	if (offset == 0)	967	if (offset == 0)
968	try_to_release_page(page, 0);	968	try_to_release_page(page, 0);
969	}	969	}
970		970
971	/**	971	/**
972	* gfs2_ok_for_dio - check that dio is valid on this file	972	* gfs2_ok_for_dio - check that dio is valid on this file
973	* @ip: The inode	973	* @ip: The inode
974	* @rw: READ or WRITE	974	* @rw: READ or WRITE
975	* @offset: The offset at which we are reading or writing	975	* @offset: The offset at which we are reading or writing
976	*	976	*
977	* Returns: 0 (to ignore the i/o request and thus fall back to buffered i/o)	977	* Returns: 0 (to ignore the i/o request and thus fall back to buffered i/o)
978	* 1 (to accept the i/o request)	978	* 1 (to accept the i/o request)
979	*/	979	*/
980	static int gfs2_ok_for_dio(struct gfs2_inode *ip, int rw, loff_t offset)	980	static int gfs2_ok_for_dio(struct gfs2_inode *ip, int rw, loff_t offset)
981	{	981	{
982	/*	982	/*
983	* Should we return an error here? I can't see that O_DIRECT for	983	* Should we return an error here? I can't see that O_DIRECT for
984	* a stuffed file makes any sense. For now we'll silently fall	984	* a stuffed file makes any sense. For now we'll silently fall
985	* back to buffered I/O	985	* back to buffered I/O
986	*/	986	*/
987	if (gfs2_is_stuffed(ip))	987	if (gfs2_is_stuffed(ip))
988	return 0;	988	return 0;
989		989
990	if (offset >= i_size_read(&ip->i_inode))	990	if (offset >= i_size_read(&ip->i_inode))
991	return 0;	991	return 0;
992	return 1;	992	return 1;
993	}	993	}
994		994
995		995
996		996
997	static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,	997	static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
998	const struct iovec *iov, loff_t offset,	998	const struct iovec *iov, loff_t offset,
999	unsigned long nr_segs)	999	unsigned long nr_segs)
1000	{	1000	{
1001	struct file *file = iocb->ki_filp;	1001	struct file *file = iocb->ki_filp;
1002	struct inode *inode = file->f_mapping->host;	1002	struct inode *inode = file->f_mapping->host;
1003	struct gfs2_inode *ip = GFS2_I(inode);	1003	struct gfs2_inode *ip = GFS2_I(inode);
1004	struct gfs2_holder gh;	1004	struct gfs2_holder gh;
1005	int rv;	1005	int rv;
1006		1006
1007	/*	1007	/*
1008	* Deferred lock, even if its a write, since we do no allocation	1008	* Deferred lock, even if its a write, since we do no allocation
1009	* on this path. All we need change is atime, and this lock mode	1009	* on this path. All we need change is atime, and this lock mode
1010	* ensures that other nodes have flushed their buffered read caches	1010	* ensures that other nodes have flushed their buffered read caches
1011	* (i.e. their page cache entries for this inode). We do not,	1011	* (i.e. their page cache entries for this inode). We do not,
1012	* unfortunately have the option of only flushing a range like	1012	* unfortunately have the option of only flushing a range like
1013	* the VFS does.	1013	* the VFS does.
1014	*/	1014	*/
1015	gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, &gh);	1015	gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, 0, &gh);
1016	rv = gfs2_glock_nq(&gh);	1016	rv = gfs2_glock_nq(&gh);
1017	if (rv)	1017	if (rv)
1018	return rv;	1018	return rv;
1019	rv = gfs2_ok_for_dio(ip, rw, offset);	1019	rv = gfs2_ok_for_dio(ip, rw, offset);
1020	if (rv != 1)	1020	if (rv != 1)
1021	goto out; /* dio not valid, fall back to buffered i/o */	1021	goto out; /* dio not valid, fall back to buffered i/o */
1022		1022
1023	rv = __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,	1023	rv = __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
1024	offset, nr_segs, gfs2_get_block_direct,	1024	offset, nr_segs, gfs2_get_block_direct,
1025	NULL, NULL, 0);	1025	NULL, NULL, 0);
1026	out:	1026	out:
1027	gfs2_glock_dq(&gh);	1027	gfs2_glock_dq(&gh);
1028	gfs2_holder_uninit(&gh);	1028	gfs2_holder_uninit(&gh);
1029	return rv;	1029	return rv;
1030	}	1030	}
1031		1031
1032	/**	1032	/**
1033	* gfs2_releasepage - free the metadata associated with a page	1033	* gfs2_releasepage - free the metadata associated with a page
1034	* @page: the page that's being released	1034	* @page: the page that's being released
1035	* @gfp_mask: passed from Linux VFS, ignored by us	1035	* @gfp_mask: passed from Linux VFS, ignored by us
1036	*	1036	*
1037	* Call try_to_free_buffers() if the buffers in this page can be	1037	* Call try_to_free_buffers() if the buffers in this page can be
1038	* released.	1038	* released.
1039	*	1039	*
1040	* Returns: 0	1040	* Returns: 0
1041	*/	1041	*/
1042		1042
1043	int gfs2_releasepage(struct page *page, gfp_t gfp_mask)	1043	int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
1044	{	1044	{
1045	struct address_space *mapping = page->mapping;	1045	struct address_space *mapping = page->mapping;
1046	struct gfs2_sbd *sdp = gfs2_mapping2sbd(mapping);	1046	struct gfs2_sbd *sdp = gfs2_mapping2sbd(mapping);
1047	struct buffer_head bh, head;	1047	struct buffer_head bh, head;
1048	struct gfs2_bufdata *bd;	1048	struct gfs2_bufdata *bd;
1049		1049
1050	if (!page_has_buffers(page))	1050	if (!page_has_buffers(page))
1051	return 0;	1051	return 0;
1052		1052
1053	gfs2_log_lock(sdp);	1053	gfs2_log_lock(sdp);
1054	spin_lock(&sdp->sd_ail_lock);	1054	spin_lock(&sdp->sd_ail_lock);
1055	head = bh = page_buffers(page);	1055	head = bh = page_buffers(page);
1056	do {	1056	do {
1057	if (atomic_read(&bh->b_count))	1057	if (atomic_read(&bh->b_count))
1058	goto cannot_release;	1058	goto cannot_release;
1059	bd = bh->b_private;	1059	bd = bh->b_private;
1060	if (bd && bd->bd_ail)	1060	if (bd && bd->bd_ail)
1061	goto cannot_release;	1061	goto cannot_release;
1062	if (buffer_pinned(bh) \|\| buffer_dirty(bh))	1062	if (buffer_pinned(bh) \|\| buffer_dirty(bh))
1063	goto not_possible;	1063	goto not_possible;
1064	bh = bh->b_this_page;	1064	bh = bh->b_this_page;
1065	} while(bh != head);	1065	} while(bh != head);
1066	spin_unlock(&sdp->sd_ail_lock);	1066	spin_unlock(&sdp->sd_ail_lock);
1067	gfs2_log_unlock(sdp);	1067	gfs2_log_unlock(sdp);
1068		1068
1069	head = bh = page_buffers(page);	1069	head = bh = page_buffers(page);
1070	do {	1070	do {
1071	gfs2_log_lock(sdp);	1071	gfs2_log_lock(sdp);
1072	bd = bh->b_private;	1072	bd = bh->b_private;
1073	if (bd) {	1073	if (bd) {
1074	gfs2_assert_warn(sdp, bd->bd_bh == bh);	1074	gfs2_assert_warn(sdp, bd->bd_bh == bh);
1075	if (!list_empty(&bd->bd_list)) {	1075	if (!list_empty(&bd->bd_list)) {
1076	if (!buffer_pinned(bh))	1076	if (!buffer_pinned(bh))
1077	list_del_init(&bd->bd_list);	1077	list_del_init(&bd->bd_list);
1078	else	1078	else
1079	bd = NULL;	1079	bd = NULL;
1080	}	1080	}
1081	if (bd)	1081	if (bd)
1082	bd->bd_bh = NULL;	1082	bd->bd_bh = NULL;
1083	bh->b_private = NULL;	1083	bh->b_private = NULL;
1084	}	1084	}
1085	gfs2_log_unlock(sdp);	1085	gfs2_log_unlock(sdp);
1086	if (bd)	1086	if (bd)
1087	kmem_cache_free(gfs2_bufdata_cachep, bd);	1087	kmem_cache_free(gfs2_bufdata_cachep, bd);
1088		1088
1089	bh = bh->b_this_page;	1089	bh = bh->b_this_page;
1090	} while (bh != head);	1090	} while (bh != head);
1091		1091
1092	return try_to_free_buffers(page);	1092	return try_to_free_buffers(page);
1093		1093
1094	not_possible: /* Should never happen */	1094	not_possible: /* Should never happen */
1095	WARN_ON(buffer_dirty(bh));	1095	WARN_ON(buffer_dirty(bh));
1096	WARN_ON(buffer_pinned(bh));	1096	WARN_ON(buffer_pinned(bh));
1097	cannot_release:	1097	cannot_release:
1098	spin_unlock(&sdp->sd_ail_lock);	1098	spin_unlock(&sdp->sd_ail_lock);
1099	gfs2_log_unlock(sdp);	1099	gfs2_log_unlock(sdp);
1100	return 0;	1100	return 0;
1101	}	1101	}
1102		1102
1103	static const struct address_space_operations gfs2_writeback_aops = {	1103	static const struct address_space_operations gfs2_writeback_aops = {
1104	.writepage = gfs2_writeback_writepage,	1104	.writepage = gfs2_writeback_writepage,
1105	.writepages = gfs2_writeback_writepages,	1105	.writepages = gfs2_writeback_writepages,
1106	.readpage = gfs2_readpage,	1106	.readpage = gfs2_readpage,
1107	.readpages = gfs2_readpages,	1107	.readpages = gfs2_readpages,
1108	.write_begin = gfs2_write_begin,	1108	.write_begin = gfs2_write_begin,
1109	.write_end = gfs2_write_end,	1109	.write_end = gfs2_write_end,
1110	.bmap = gfs2_bmap,	1110	.bmap = gfs2_bmap,
1111	.invalidatepage = gfs2_invalidatepage,	1111	.invalidatepage = gfs2_invalidatepage,
1112	.releasepage = gfs2_releasepage,	1112	.releasepage = gfs2_releasepage,
1113	.direct_IO = gfs2_direct_IO,	1113	.direct_IO = gfs2_direct_IO,
1114	.migratepage = buffer_migrate_page,	1114	.migratepage = buffer_migrate_page,
1115	.is_partially_uptodate = block_is_partially_uptodate,	1115	.is_partially_uptodate = block_is_partially_uptodate,
1116	.error_remove_page = generic_error_remove_page,	1116	.error_remove_page = generic_error_remove_page,
1117	};	1117	};
1118		1118
1119	static const struct address_space_operations gfs2_ordered_aops = {	1119	static const struct address_space_operations gfs2_ordered_aops = {
1120	.writepage = gfs2_ordered_writepage,	1120	.writepage = gfs2_ordered_writepage,
1121	.readpage = gfs2_readpage,	1121	.readpage = gfs2_readpage,
1122	.readpages = gfs2_readpages,	1122	.readpages = gfs2_readpages,
1123	.write_begin = gfs2_write_begin,	1123	.write_begin = gfs2_write_begin,
1124	.write_end = gfs2_write_end,	1124	.write_end = gfs2_write_end,
1125	.set_page_dirty = gfs2_set_page_dirty,	1125	.set_page_dirty = gfs2_set_page_dirty,
1126	.bmap = gfs2_bmap,	1126	.bmap = gfs2_bmap,
1127	.invalidatepage = gfs2_invalidatepage,	1127	.invalidatepage = gfs2_invalidatepage,
1128	.releasepage = gfs2_releasepage,	1128	.releasepage = gfs2_releasepage,
1129	.direct_IO = gfs2_direct_IO,	1129	.direct_IO = gfs2_direct_IO,
1130	.migratepage = buffer_migrate_page,	1130	.migratepage = buffer_migrate_page,
1131	.is_partially_uptodate = block_is_partially_uptodate,	1131	.is_partially_uptodate = block_is_partially_uptodate,
1132	.error_remove_page = generic_error_remove_page,	1132	.error_remove_page = generic_error_remove_page,
1133	};	1133	};
1134		1134
1135	static const struct address_space_operations gfs2_jdata_aops = {	1135	static const struct address_space_operations gfs2_jdata_aops = {
1136	.writepage = gfs2_jdata_writepage,	1136	.writepage = gfs2_jdata_writepage,
1137	.writepages = gfs2_jdata_writepages,	1137	.writepages = gfs2_jdata_writepages,
1138	.readpage = gfs2_readpage,	1138	.readpage = gfs2_readpage,
1139	.readpages = gfs2_readpages,	1139	.readpages = gfs2_readpages,
1140	.write_begin = gfs2_write_begin,	1140	.write_begin = gfs2_write_begin,
1141	.write_end = gfs2_write_end,	1141	.write_end = gfs2_write_end,
1142	.set_page_dirty = gfs2_set_page_dirty,	1142	.set_page_dirty = gfs2_set_page_dirty,
1143	.bmap = gfs2_bmap,	1143	.bmap = gfs2_bmap,
1144	.invalidatepage = gfs2_invalidatepage,	1144	.invalidatepage = gfs2_invalidatepage,
1145	.releasepage = gfs2_releasepage,	1145	.releasepage = gfs2_releasepage,
1146	.is_partially_uptodate = block_is_partially_uptodate,	1146	.is_partially_uptodate = block_is_partially_uptodate,
1147	.error_remove_page = generic_error_remove_page,	1147	.error_remove_page = generic_error_remove_page,
1148	};	1148	};
1149		1149
1150	void gfs2_set_aops(struct inode *inode)	1150	void gfs2_set_aops(struct inode *inode)
1151	{	1151	{
1152	struct gfs2_inode *ip = GFS2_I(inode);	1152	struct gfs2_inode *ip = GFS2_I(inode);
1153		1153
1154	if (gfs2_is_writeback(ip))	1154	if (gfs2_is_writeback(ip))
1155	inode->i_mapping->a_ops = &gfs2_writeback_aops;	1155	inode->i_mapping->a_ops = &gfs2_writeback_aops;
1156	else if (gfs2_is_ordered(ip))	1156	else if (gfs2_is_ordered(ip))
1157	inode->i_mapping->a_ops = &gfs2_ordered_aops;	1157	inode->i_mapping->a_ops = &gfs2_ordered_aops;
1158	else if (gfs2_is_jdata(ip))	1158	else if (gfs2_is_jdata(ip))
1159	inode->i_mapping->a_ops = &gfs2_jdata_aops;	1159	inode->i_mapping->a_ops = &gfs2_jdata_aops;
1160	else	1160	else
1161	BUG();	1161	BUG();
1162	}	1162	}
1163		1163
1164		1164

fs/gfs2/bmap.c

Diff comments View file @ 9dbe961

1	/*	1	/*
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.	3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4	*	4	*
5	* This copyrighted material is made available to anyone wishing to use,	5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions	6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.	7	* of the GNU General Public License version 2.
8	*/	8	*/
9		9
10	#include <linux/spinlock.h>	10	#include <linux/spinlock.h>
11	#include <linux/completion.h>	11	#include <linux/completion.h>
12	#include <linux/buffer_head.h>	12	#include <linux/buffer_head.h>
13	#include <linux/blkdev.h>	13	#include <linux/blkdev.h>
14	#include <linux/gfs2_ondisk.h>	14	#include <linux/gfs2_ondisk.h>
15	#include <linux/crc32.h>	15	#include <linux/crc32.h>
16		16
17	#include "gfs2.h"	17	#include "gfs2.h"
18	#include "incore.h"	18	#include "incore.h"
19	#include "bmap.h"	19	#include "bmap.h"
20	#include "glock.h"	20	#include "glock.h"
21	#include "inode.h"	21	#include "inode.h"
22	#include "meta_io.h"	22	#include "meta_io.h"
23	#include "quota.h"	23	#include "quota.h"
24	#include "rgrp.h"	24	#include "rgrp.h"
25	#include "super.h"	25	#include "super.h"
26	#include "trans.h"	26	#include "trans.h"
27	#include "dir.h"	27	#include "dir.h"
28	#include "util.h"	28	#include "util.h"
29	#include "trace_gfs2.h"	29	#include "trace_gfs2.h"
30		30
31	/* This doesn't need to be that large as max 64 bit pointers in a 4k	31	/* This doesn't need to be that large as max 64 bit pointers in a 4k
32	* block is 512, so __u16 is fine for that. It saves stack space to	32	* block is 512, so __u16 is fine for that. It saves stack space to
33	* keep it small.	33	* keep it small.
34	*/	34	*/
35	struct metapath {	35	struct metapath {
36	struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];	36	struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];
37	__u16 mp_list[GFS2_MAX_META_HEIGHT];	37	__u16 mp_list[GFS2_MAX_META_HEIGHT];
38	};	38	};
39		39
40	struct strip_mine {	40	struct strip_mine {
41	int sm_first;	41	int sm_first;
42	unsigned int sm_height;	42	unsigned int sm_height;
43	};	43	};
44		44
45	/**	45	/**
46	* gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page	46	* gfs2_unstuffer_page - unstuff a stuffed inode into a block cached by a page
47	* @ip: the inode	47	* @ip: the inode
48	* @dibh: the dinode buffer	48	* @dibh: the dinode buffer
49	* @block: the block number that was allocated	49	* @block: the block number that was allocated
50	* @page: The (optional) page. This is looked up if @page is NULL	50	* @page: The (optional) page. This is looked up if @page is NULL
51	*	51	*
52	* Returns: errno	52	* Returns: errno
53	*/	53	*/
54		54
55	static int gfs2_unstuffer_page(struct gfs2_inode ip, struct buffer_head dibh,	55	static int gfs2_unstuffer_page(struct gfs2_inode ip, struct buffer_head dibh,
56	u64 block, struct page *page)	56	u64 block, struct page *page)
57	{	57	{
58	struct inode *inode = &ip->i_inode;	58	struct inode *inode = &ip->i_inode;
59	struct buffer_head *bh;	59	struct buffer_head *bh;
60	int release = 0;	60	int release = 0;
61		61
62	if (!page \|\| page->index) {	62	if (!page \|\| page->index) {
63	page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);	63	page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
64	if (!page)	64	if (!page)
65	return -ENOMEM;	65	return -ENOMEM;
66	release = 1;	66	release = 1;
67	}	67	}
68		68
69	if (!PageUptodate(page)) {	69	if (!PageUptodate(page)) {
70	void *kaddr = kmap(page);	70	void *kaddr = kmap(page);
71	u64 dsize = i_size_read(inode);	71	u64 dsize = i_size_read(inode);
72		72
73	if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode)))	73	if (dsize > (dibh->b_size - sizeof(struct gfs2_dinode)))
74	dsize = dibh->b_size - sizeof(struct gfs2_dinode);	74	dsize = dibh->b_size - sizeof(struct gfs2_dinode);
75		75
76	memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);	76	memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode), dsize);
77	memset(kaddr + dsize, 0, PAGE_CACHE_SIZE - dsize);	77	memset(kaddr + dsize, 0, PAGE_CACHE_SIZE - dsize);
78	kunmap(page);	78	kunmap(page);
79		79
80	SetPageUptodate(page);	80	SetPageUptodate(page);
81	}	81	}
82		82
83	if (!page_has_buffers(page))	83	if (!page_has_buffers(page))
84	create_empty_buffers(page, 1 << inode->i_blkbits,	84	create_empty_buffers(page, 1 << inode->i_blkbits,
85	(1 << BH_Uptodate));	85	(1 << BH_Uptodate));
86		86
87	bh = page_buffers(page);	87	bh = page_buffers(page);
88		88
89	if (!buffer_mapped(bh))	89	if (!buffer_mapped(bh))
90	map_bh(bh, inode->i_sb, block);	90	map_bh(bh, inode->i_sb, block);
91		91
92	set_buffer_uptodate(bh);	92	set_buffer_uptodate(bh);
93	if (!gfs2_is_jdata(ip))	93	if (!gfs2_is_jdata(ip))
94	mark_buffer_dirty(bh);	94	mark_buffer_dirty(bh);
95	if (!gfs2_is_writeback(ip))	95	if (!gfs2_is_writeback(ip))
96	gfs2_trans_add_bh(ip->i_gl, bh, 0);	96	gfs2_trans_add_bh(ip->i_gl, bh, 0);
97		97
98	if (release) {	98	if (release) {
99	unlock_page(page);	99	unlock_page(page);
100	page_cache_release(page);	100	page_cache_release(page);
101	}	101	}
102		102
103	return 0;	103	return 0;
104	}	104	}
105		105
106	/**	106	/**
107	* gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big	107	* gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big
108	* @ip: The GFS2 inode to unstuff	108	* @ip: The GFS2 inode to unstuff
109	* @page: The (optional) page. This is looked up if the @page is NULL	109	* @page: The (optional) page. This is looked up if the @page is NULL
110	*	110	*
111	* This routine unstuffs a dinode and returns it to a "normal" state such	111	* This routine unstuffs a dinode and returns it to a "normal" state such
112	* that the height can be grown in the traditional way.	112	* that the height can be grown in the traditional way.
113	*	113	*
114	* Returns: errno	114	* Returns: errno
115	*/	115	*/
116		116
117	int gfs2_unstuff_dinode(struct gfs2_inode ip, struct page page)	117	int gfs2_unstuff_dinode(struct gfs2_inode ip, struct page page)
118	{	118	{
119	struct buffer_head bh, dibh;	119	struct buffer_head bh, dibh;
120	struct gfs2_dinode *di;	120	struct gfs2_dinode *di;
121	u64 block = 0;	121	u64 block = 0;
122	int isdir = gfs2_is_dir(ip);	122	int isdir = gfs2_is_dir(ip);
123	int error;	123	int error;
124		124
125	down_write(&ip->i_rw_mutex);	125	down_write(&ip->i_rw_mutex);
126		126
127	error = gfs2_meta_inode_buffer(ip, &dibh);	127	error = gfs2_meta_inode_buffer(ip, &dibh);
128	if (error)	128	if (error)
129	goto out;	129	goto out;
130		130
131	if (i_size_read(&ip->i_inode)) {	131	if (i_size_read(&ip->i_inode)) {
132	/* Get a free block, fill it with the stuffed data,	132	/* Get a free block, fill it with the stuffed data,
133	and write it out to disk */	133	and write it out to disk */
134		134
135	unsigned int n = 1;	135	unsigned int n = 1;
136	error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);	136	error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
137	if (error)	137	if (error)
138	goto out_brelse;	138	goto out_brelse;
139	if (isdir) {	139	if (isdir) {
140	gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);	140	gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
141	error = gfs2_dir_get_new_buffer(ip, block, &bh);	141	error = gfs2_dir_get_new_buffer(ip, block, &bh);
142	if (error)	142	if (error)
143	goto out_brelse;	143	goto out_brelse;
144	gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header),	144	gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_meta_header),
145	dibh, sizeof(struct gfs2_dinode));	145	dibh, sizeof(struct gfs2_dinode));
146	brelse(bh);	146	brelse(bh);
147	} else {	147	} else {
148	error = gfs2_unstuffer_page(ip, dibh, block, page);	148	error = gfs2_unstuffer_page(ip, dibh, block, page);
149	if (error)	149	if (error)
150	goto out_brelse;	150	goto out_brelse;
151	}	151	}
152	}	152	}
153		153
154	/* Set up the pointer to the new block */	154	/* Set up the pointer to the new block */
155		155
156	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	156	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
157	di = (struct gfs2_dinode *)dibh->b_data;	157	di = (struct gfs2_dinode *)dibh->b_data;
158	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));	158	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
159		159
160	if (i_size_read(&ip->i_inode)) {	160	if (i_size_read(&ip->i_inode)) {
161	(__be64 )(di + 1) = cpu_to_be64(block);	161	(__be64 )(di + 1) = cpu_to_be64(block);
162	gfs2_add_inode_blocks(&ip->i_inode, 1);	162	gfs2_add_inode_blocks(&ip->i_inode, 1);
163	di->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));	163	di->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode));
164	}	164	}
165		165
166	ip->i_height = 1;	166	ip->i_height = 1;
167	di->di_height = cpu_to_be16(1);	167	di->di_height = cpu_to_be16(1);
168		168
169	out_brelse:	169	out_brelse:
170	brelse(dibh);	170	brelse(dibh);
171	out:	171	out:
172	up_write(&ip->i_rw_mutex);	172	up_write(&ip->i_rw_mutex);
173	return error;	173	return error;
174	}	174	}
175		175
176		176
177	/**	177	/**
178	* find_metapath - Find path through the metadata tree	178	* find_metapath - Find path through the metadata tree
179	* @sdp: The superblock	179	* @sdp: The superblock
180	* @mp: The metapath to return the result in	180	* @mp: The metapath to return the result in
181	* @block: The disk block to look up	181	* @block: The disk block to look up
182	* @height: The pre-calculated height of the metadata tree	182	* @height: The pre-calculated height of the metadata tree
183	*	183	*
184	* This routine returns a struct metapath structure that defines a path	184	* This routine returns a struct metapath structure that defines a path
185	* through the metadata of inode "ip" to get to block "block".	185	* through the metadata of inode "ip" to get to block "block".
186	*	186	*
187	* Example:	187	* Example:
188	* Given: "ip" is a height 3 file, "offset" is 101342453, and this is a	188	* Given: "ip" is a height 3 file, "offset" is 101342453, and this is a
189	* filesystem with a blocksize of 4096.	189	* filesystem with a blocksize of 4096.
190	*	190	*
191	* find_metapath() would return a struct metapath structure set to:	191	* find_metapath() would return a struct metapath structure set to:
192	* mp_offset = 101342453, mp_height = 3, mp_list[0] = 0, mp_list[1] = 48,	192	* mp_offset = 101342453, mp_height = 3, mp_list[0] = 0, mp_list[1] = 48,
193	* and mp_list[2] = 165.	193	* and mp_list[2] = 165.
194	*	194	*
195	* That means that in order to get to the block containing the byte at	195	* That means that in order to get to the block containing the byte at
196	* offset 101342453, we would load the indirect block pointed to by pointer	196	* offset 101342453, we would load the indirect block pointed to by pointer
197	* 0 in the dinode. We would then load the indirect block pointed to by	197	* 0 in the dinode. We would then load the indirect block pointed to by
198	* pointer 48 in that indirect block. We would then load the data block	198	* pointer 48 in that indirect block. We would then load the data block
199	* pointed to by pointer 165 in that indirect block.	199	* pointed to by pointer 165 in that indirect block.
200	*	200	*
201	* ----------------------------------------	201	* ----------------------------------------
202	* \| Dinode \| \|	202	* \| Dinode \| \|
203	* \| \| 4\|	203	* \| \| 4\|
204	* \| \|0 1 2 3 4 5 9\|	204	* \| \|0 1 2 3 4 5 9\|
205	* \| \| 6\|	205	* \| \| 6\|
206	* ----------------------------------------	206	* ----------------------------------------
207	* \|	207	* \|
208	* \|	208	* \|
209	* V	209	* V
210	* ----------------------------------------	210	* ----------------------------------------
211	* \| Indirect Block \|	211	* \| Indirect Block \|
212	* \| 5\|	212	* \| 5\|
213	* \| 4 4 4 4 4 5 5 1\|	213	* \| 4 4 4 4 4 5 5 1\|
214	* \|0 5 6 7 8 9 0 1 2\|	214	* \|0 5 6 7 8 9 0 1 2\|
215	* ----------------------------------------	215	* ----------------------------------------
216	* \|	216	* \|
217	* \|	217	* \|
218	* V	218	* V
219	* ----------------------------------------	219	* ----------------------------------------
220	* \| Indirect Block \|	220	* \| Indirect Block \|
221	* \| 1 1 1 1 1 5\|	221	* \| 1 1 1 1 1 5\|
222	* \| 6 6 6 6 6 1\|	222	* \| 6 6 6 6 6 1\|
223	* \|0 3 4 5 6 7 2\|	223	* \|0 3 4 5 6 7 2\|
224	* ----------------------------------------	224	* ----------------------------------------
225	* \|	225	* \|
226	* \|	226	* \|
227	* V	227	* V
228	* ----------------------------------------	228	* ----------------------------------------
229	* \| Data block containing offset \|	229	* \| Data block containing offset \|
230	* \| 101342453 \|	230	* \| 101342453 \|
231	* \| \|	231	* \| \|
232	* \| \|	232	* \| \|
233	* ----------------------------------------	233	* ----------------------------------------
234	*	234	*
235	*/	235	*/
236		236
237	static void find_metapath(const struct gfs2_sbd *sdp, u64 block,	237	static void find_metapath(const struct gfs2_sbd *sdp, u64 block,
238	struct metapath *mp, unsigned int height)	238	struct metapath *mp, unsigned int height)
239	{	239	{
240	unsigned int i;	240	unsigned int i;
241		241
242	for (i = height; i--;)	242	for (i = height; i--;)
243	mp->mp_list[i] = do_div(block, sdp->sd_inptrs);	243	mp->mp_list[i] = do_div(block, sdp->sd_inptrs);
244		244
245	}	245	}
246		246
247	static inline unsigned int metapath_branch_start(const struct metapath *mp)	247	static inline unsigned int metapath_branch_start(const struct metapath *mp)
248	{	248	{
249	if (mp->mp_list[0] == 0)	249	if (mp->mp_list[0] == 0)
250	return 2;	250	return 2;
251	return 1;	251	return 1;
252	}	252	}
253		253
254	/**	254	/**
255	* metapointer - Return pointer to start of metadata in a buffer	255	* metapointer - Return pointer to start of metadata in a buffer
256	* @height: The metadata height (0 = dinode)	256	* @height: The metadata height (0 = dinode)
257	* @mp: The metapath	257	* @mp: The metapath
258	*	258	*
259	* Return a pointer to the block number of the next height of the metadata	259	* Return a pointer to the block number of the next height of the metadata
260	* tree given a buffer containing the pointer to the current height of the	260	* tree given a buffer containing the pointer to the current height of the
261	* metadata tree.	261	* metadata tree.
262	*/	262	*/
263		263
264	static inline __be64 metapointer(unsigned int height, const struct metapath mp)	264	static inline __be64 metapointer(unsigned int height, const struct metapath mp)
265	{	265	{
266	struct buffer_head *bh = mp->mp_bh[height];	266	struct buffer_head *bh = mp->mp_bh[height];
267	unsigned int head_size = (height > 0) ?	267	unsigned int head_size = (height > 0) ?
268	sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_dinode);	268	sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_dinode);
269	return ((__be64 *)(bh->b_data + head_size)) + mp->mp_list[height];	269	return ((__be64 *)(bh->b_data + head_size)) + mp->mp_list[height];
270	}	270	}
271		271
272	static void gfs2_metapath_ra(struct gfs2_glock *gl,	272	static void gfs2_metapath_ra(struct gfs2_glock *gl,
273	const struct buffer_head bh, const __be64 pos)	273	const struct buffer_head bh, const __be64 pos)
274	{	274	{
275	struct buffer_head *rabh;	275	struct buffer_head *rabh;
276	const __be64 endp = (const __be64 )(bh->b_data + bh->b_size);	276	const __be64 endp = (const __be64 )(bh->b_data + bh->b_size);
277	const __be64 *t;	277	const __be64 *t;
278		278
279	for (t = pos; t < endp; t++) {	279	for (t = pos; t < endp; t++) {
280	if (!*t)	280	if (!*t)
281	continue;	281	continue;
282		282
283	rabh = gfs2_getbuf(gl, be64_to_cpu(*t), CREATE);	283	rabh = gfs2_getbuf(gl, be64_to_cpu(*t), CREATE);
284	if (trylock_buffer(rabh)) {	284	if (trylock_buffer(rabh)) {
285	if (!buffer_uptodate(rabh)) {	285	if (!buffer_uptodate(rabh)) {
286	rabh->b_end_io = end_buffer_read_sync;	286	rabh->b_end_io = end_buffer_read_sync;
287	submit_bh(READA \| REQ_META, rabh);	287	submit_bh(READA \| REQ_META, rabh);
288	continue;	288	continue;
289	}	289	}
290	unlock_buffer(rabh);	290	unlock_buffer(rabh);
291	}	291	}
292	brelse(rabh);	292	brelse(rabh);
293	}	293	}
294	}	294	}
295		295
296	/**	296	/**
297	* lookup_metapath - Walk the metadata tree to a specific point	297	* lookup_metapath - Walk the metadata tree to a specific point
298	* @ip: The inode	298	* @ip: The inode
299	* @mp: The metapath	299	* @mp: The metapath
300	*	300	*
301	* Assumes that the inode's buffer has already been looked up and	301	* Assumes that the inode's buffer has already been looked up and
302	* hooked onto mp->mp_bh[0] and that the metapath has been initialised	302	* hooked onto mp->mp_bh[0] and that the metapath has been initialised
303	* by find_metapath().	303	* by find_metapath().
304	*	304	*
305	* If this function encounters part of the tree which has not been	305	* If this function encounters part of the tree which has not been
306	* allocated, it returns the current height of the tree at the point	306	* allocated, it returns the current height of the tree at the point
307	* at which it found the unallocated block. Blocks which are found are	307	* at which it found the unallocated block. Blocks which are found are
308	* added to the mp->mp_bh[] list.	308	* added to the mp->mp_bh[] list.
309	*	309	*
310	* Returns: error or height of metadata tree	310	* Returns: error or height of metadata tree
311	*/	311	*/
312		312
313	static int lookup_metapath(struct gfs2_inode ip, struct metapath mp)	313	static int lookup_metapath(struct gfs2_inode ip, struct metapath mp)
314	{	314	{
315	unsigned int end_of_metadata = ip->i_height - 1;	315	unsigned int end_of_metadata = ip->i_height - 1;
316	unsigned int x;	316	unsigned int x;
317	__be64 *ptr;	317	__be64 *ptr;
318	u64 dblock;	318	u64 dblock;
319	int ret;	319	int ret;
320		320
321	for (x = 0; x < end_of_metadata; x++) {	321	for (x = 0; x < end_of_metadata; x++) {
322	ptr = metapointer(x, mp);	322	ptr = metapointer(x, mp);
323	dblock = be64_to_cpu(*ptr);	323	dblock = be64_to_cpu(*ptr);
324	if (!dblock)	324	if (!dblock)
325	return x + 1;	325	return x + 1;
326		326
327	ret = gfs2_meta_indirect_buffer(ip, x+1, dblock, &mp->mp_bh[x+1]);	327	ret = gfs2_meta_indirect_buffer(ip, x+1, dblock, &mp->mp_bh[x+1]);
328	if (ret)	328	if (ret)
329	return ret;	329	return ret;
330	}	330	}
331		331
332	return ip->i_height;	332	return ip->i_height;
333	}	333	}
334		334
335	static inline void release_metapath(struct metapath *mp)	335	static inline void release_metapath(struct metapath *mp)
336	{	336	{
337	int i;	337	int i;
338		338
339	for (i = 0; i < GFS2_MAX_META_HEIGHT; i++) {	339	for (i = 0; i < GFS2_MAX_META_HEIGHT; i++) {
340	if (mp->mp_bh[i] == NULL)	340	if (mp->mp_bh[i] == NULL)
341	break;	341	break;
342	brelse(mp->mp_bh[i]);	342	brelse(mp->mp_bh[i]);
343	}	343	}
344	}	344	}
345		345
346	/**	346	/**
347	* gfs2_extent_length - Returns length of an extent of blocks	347	* gfs2_extent_length - Returns length of an extent of blocks
348	* @start: Start of the buffer	348	* @start: Start of the buffer
349	* @len: Length of the buffer in bytes	349	* @len: Length of the buffer in bytes
350	* @ptr: Current position in the buffer	350	* @ptr: Current position in the buffer
351	* @limit: Max extent length to return (0 = unlimited)	351	* @limit: Max extent length to return (0 = unlimited)
352	* @eob: Set to 1 if we hit "end of block"	352	* @eob: Set to 1 if we hit "end of block"
353	*	353	*
354	* If the first block is zero (unallocated) it will return the number of	354	* If the first block is zero (unallocated) it will return the number of
355	* unallocated blocks in the extent, otherwise it will return the number	355	* unallocated blocks in the extent, otherwise it will return the number
356	* of contiguous blocks in the extent.	356	* of contiguous blocks in the extent.
357	*	357	*
358	* Returns: The length of the extent (minimum of one block)	358	* Returns: The length of the extent (minimum of one block)
359	*/	359	*/
360		360
361	static inline unsigned int gfs2_extent_length(void start, unsigned int len, __be64 ptr, unsigned limit, int *eob)	361	static inline unsigned int gfs2_extent_length(void start, unsigned int len, __be64 ptr, unsigned limit, int *eob)
362	{	362	{
363	const __be64 *end = (start + len);	363	const __be64 *end = (start + len);
364	const __be64 *first = ptr;	364	const __be64 *first = ptr;
365	u64 d = be64_to_cpu(*ptr);	365	u64 d = be64_to_cpu(*ptr);
366		366
367	*eob = 0;	367	*eob = 0;
368	do {	368	do {
369	ptr++;	369	ptr++;
370	if (ptr >= end)	370	if (ptr >= end)
371	break;	371	break;
372	if (limit && --limit == 0)	372	if (limit && --limit == 0)
373	break;	373	break;
374	if (d)	374	if (d)
375	d++;	375	d++;
376	} while(be64_to_cpu(*ptr) == d);	376	} while(be64_to_cpu(*ptr) == d);
377	if (ptr >= end)	377	if (ptr >= end)
378	*eob = 1;	378	*eob = 1;
379	return (ptr - first);	379	return (ptr - first);
380	}	380	}
381		381
382	static inline void bmap_lock(struct gfs2_inode *ip, int create)	382	static inline void bmap_lock(struct gfs2_inode *ip, int create)
383	{	383	{
384	if (create)	384	if (create)
385	down_write(&ip->i_rw_mutex);	385	down_write(&ip->i_rw_mutex);
386	else	386	else
387	down_read(&ip->i_rw_mutex);	387	down_read(&ip->i_rw_mutex);
388	}	388	}
389		389
390	static inline void bmap_unlock(struct gfs2_inode *ip, int create)	390	static inline void bmap_unlock(struct gfs2_inode *ip, int create)
391	{	391	{
392	if (create)	392	if (create)
393	up_write(&ip->i_rw_mutex);	393	up_write(&ip->i_rw_mutex);
394	else	394	else
395	up_read(&ip->i_rw_mutex);	395	up_read(&ip->i_rw_mutex);
396	}	396	}
397		397
398	static inline __be64 gfs2_indirect_init(struct metapath mp,	398	static inline __be64 gfs2_indirect_init(struct metapath mp,
399	struct gfs2_glock *gl, unsigned int i,	399	struct gfs2_glock *gl, unsigned int i,
400	unsigned offset, u64 bn)	400	unsigned offset, u64 bn)
401	{	401	{
402	__be64 ptr = (__be64 )(mp->mp_bh[i - 1]->b_data +	402	__be64 ptr = (__be64 )(mp->mp_bh[i - 1]->b_data +
403	((i > 1) ? sizeof(struct gfs2_meta_header) :	403	((i > 1) ? sizeof(struct gfs2_meta_header) :
404	sizeof(struct gfs2_dinode)));	404	sizeof(struct gfs2_dinode)));
405	BUG_ON(i < 1);	405	BUG_ON(i < 1);
406	BUG_ON(mp->mp_bh[i] != NULL);	406	BUG_ON(mp->mp_bh[i] != NULL);
407	mp->mp_bh[i] = gfs2_meta_new(gl, bn);	407	mp->mp_bh[i] = gfs2_meta_new(gl, bn);
408	gfs2_trans_add_bh(gl, mp->mp_bh[i], 1);	408	gfs2_trans_add_bh(gl, mp->mp_bh[i], 1);
409	gfs2_metatype_set(mp->mp_bh[i], GFS2_METATYPE_IN, GFS2_FORMAT_IN);	409	gfs2_metatype_set(mp->mp_bh[i], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
410	gfs2_buffer_clear_tail(mp->mp_bh[i], sizeof(struct gfs2_meta_header));	410	gfs2_buffer_clear_tail(mp->mp_bh[i], sizeof(struct gfs2_meta_header));
411	ptr += offset;	411	ptr += offset;
412	*ptr = cpu_to_be64(bn);	412	*ptr = cpu_to_be64(bn);
413	return ptr;	413	return ptr;
414	}	414	}
415		415
416	enum alloc_state {	416	enum alloc_state {
417	ALLOC_DATA = 0,	417	ALLOC_DATA = 0,
418	ALLOC_GROW_DEPTH = 1,	418	ALLOC_GROW_DEPTH = 1,
419	ALLOC_GROW_HEIGHT = 2,	419	ALLOC_GROW_HEIGHT = 2,
420	/* ALLOC_UNSTUFF = 3, TBD and rather complicated */	420	/* ALLOC_UNSTUFF = 3, TBD and rather complicated */
421	};	421	};
422		422
423	/**	423	/**
424	* gfs2_bmap_alloc - Build a metadata tree of the requested height	424	* gfs2_bmap_alloc - Build a metadata tree of the requested height
425	* @inode: The GFS2 inode	425	* @inode: The GFS2 inode
426	* @lblock: The logical starting block of the extent	426	* @lblock: The logical starting block of the extent
427	* @bh_map: This is used to return the mapping details	427	* @bh_map: This is used to return the mapping details
428	* @mp: The metapath	428	* @mp: The metapath
429	* @sheight: The starting height (i.e. whats already mapped)	429	* @sheight: The starting height (i.e. whats already mapped)
430	* @height: The height to build to	430	* @height: The height to build to
431	* @maxlen: The max number of data blocks to alloc	431	* @maxlen: The max number of data blocks to alloc
432	*	432	*
433	* In this routine we may have to alloc:	433	* In this routine we may have to alloc:
434	* i) Indirect blocks to grow the metadata tree height	434	* i) Indirect blocks to grow the metadata tree height
435	* ii) Indirect blocks to fill in lower part of the metadata tree	435	* ii) Indirect blocks to fill in lower part of the metadata tree
436	* iii) Data blocks	436	* iii) Data blocks
437	*	437	*
438	* The function is in two parts. The first part works out the total	438	* The function is in two parts. The first part works out the total
439	* number of blocks which we need. The second part does the actual	439	* number of blocks which we need. The second part does the actual
440	* allocation asking for an extent at a time (if enough contiguous free	440	* allocation asking for an extent at a time (if enough contiguous free
441	* blocks are available, there will only be one request per bmap call)	441	* blocks are available, there will only be one request per bmap call)
442	* and uses the state machine to initialise the blocks in order.	442	* and uses the state machine to initialise the blocks in order.
443	*	443	*
444	* Returns: errno on error	444	* Returns: errno on error
445	*/	445	*/
446		446
447	static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,	447	static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,
448	struct buffer_head bh_map, struct metapath mp,	448	struct buffer_head bh_map, struct metapath mp,
449	const unsigned int sheight,	449	const unsigned int sheight,
450	const unsigned int height,	450	const unsigned int height,
451	const unsigned int maxlen)	451	const unsigned int maxlen)
452	{	452	{
453	struct gfs2_inode *ip = GFS2_I(inode);	453	struct gfs2_inode *ip = GFS2_I(inode);
454	struct gfs2_sbd *sdp = GFS2_SB(inode);	454	struct gfs2_sbd *sdp = GFS2_SB(inode);
455	struct super_block *sb = sdp->sd_vfs;	455	struct super_block *sb = sdp->sd_vfs;
456	struct buffer_head *dibh = mp->mp_bh[0];	456	struct buffer_head *dibh = mp->mp_bh[0];
457	u64 bn, dblock = 0;	457	u64 bn, dblock = 0;
458	unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0;	458	unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0;
459	unsigned dblks = 0;	459	unsigned dblks = 0;
460	unsigned ptrs_per_blk;	460	unsigned ptrs_per_blk;
461	const unsigned end_of_metadata = height - 1;	461	const unsigned end_of_metadata = height - 1;
462	int ret;	462	int ret;
463	int eob = 0;	463	int eob = 0;
464	enum alloc_state state;	464	enum alloc_state state;
465	__be64 *ptr;	465	__be64 *ptr;
466	__be64 zero_bn = 0;	466	__be64 zero_bn = 0;
467		467
468	BUG_ON(sheight < 1);	468	BUG_ON(sheight < 1);
469	BUG_ON(dibh == NULL);	469	BUG_ON(dibh == NULL);
470		470
471	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	471	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
472		472
473	if (height == sheight) {	473	if (height == sheight) {
474	struct buffer_head *bh;	474	struct buffer_head *bh;
475	/* Bottom indirect block exists, find unalloced extent size */	475	/* Bottom indirect block exists, find unalloced extent size */
476	ptr = metapointer(end_of_metadata, mp);	476	ptr = metapointer(end_of_metadata, mp);
477	bh = mp->mp_bh[end_of_metadata];	477	bh = mp->mp_bh[end_of_metadata];
478	dblks = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen,	478	dblks = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen,
479	&eob);	479	&eob);
480	BUG_ON(dblks < 1);	480	BUG_ON(dblks < 1);
481	state = ALLOC_DATA;	481	state = ALLOC_DATA;
482	} else {	482	} else {
483	/* Need to allocate indirect blocks */	483	/* Need to allocate indirect blocks */
484	ptrs_per_blk = height > 1 ? sdp->sd_inptrs : sdp->sd_diptrs;	484	ptrs_per_blk = height > 1 ? sdp->sd_inptrs : sdp->sd_diptrs;
485	dblks = min(maxlen, ptrs_per_blk - mp->mp_list[end_of_metadata]);	485	dblks = min(maxlen, ptrs_per_blk - mp->mp_list[end_of_metadata]);
486	if (height == ip->i_height) {	486	if (height == ip->i_height) {
487	/* Writing into existing tree, extend tree down */	487	/* Writing into existing tree, extend tree down */
488	iblks = height - sheight;	488	iblks = height - sheight;
489	state = ALLOC_GROW_DEPTH;	489	state = ALLOC_GROW_DEPTH;
490	} else {	490	} else {
491	/* Building up tree height */	491	/* Building up tree height */
492	state = ALLOC_GROW_HEIGHT;	492	state = ALLOC_GROW_HEIGHT;
493	iblks = height - ip->i_height;	493	iblks = height - ip->i_height;
494	branch_start = metapath_branch_start(mp);	494	branch_start = metapath_branch_start(mp);
495	iblks += (height - branch_start);	495	iblks += (height - branch_start);
496	}	496	}
497	}	497	}
498		498
499	/* start of the second part of the function (state machine) */	499	/* start of the second part of the function (state machine) */
500		500
501	blks = dblks + iblks;	501	blks = dblks + iblks;
502	i = sheight;	502	i = sheight;
503	do {	503	do {
504	int error;	504	int error;
505	n = blks - alloced;	505	n = blks - alloced;
506	error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);	506	error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
507	if (error)	507	if (error)
508	return error;	508	return error;
509	alloced += n;	509	alloced += n;
510	if (state != ALLOC_DATA \|\| gfs2_is_jdata(ip))	510	if (state != ALLOC_DATA \|\| gfs2_is_jdata(ip))
511	gfs2_trans_add_unrevoke(sdp, bn, n);	511	gfs2_trans_add_unrevoke(sdp, bn, n);
512	switch (state) {	512	switch (state) {
513	/* Growing height of tree */	513	/* Growing height of tree */
514	case ALLOC_GROW_HEIGHT:	514	case ALLOC_GROW_HEIGHT:
515	if (i == 1) {	515	if (i == 1) {
516	ptr = (__be64 *)(dibh->b_data +	516	ptr = (__be64 *)(dibh->b_data +
517	sizeof(struct gfs2_dinode));	517	sizeof(struct gfs2_dinode));
518	zero_bn = *ptr;	518	zero_bn = *ptr;
519	}	519	}
520	for (; i - 1 < height - ip->i_height && n > 0; i++, n--)	520	for (; i - 1 < height - ip->i_height && n > 0; i++, n--)
521	gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++);	521	gfs2_indirect_init(mp, ip->i_gl, i, 0, bn++);
522	if (i - 1 == height - ip->i_height) {	522	if (i - 1 == height - ip->i_height) {
523	i--;	523	i--;
524	gfs2_buffer_copy_tail(mp->mp_bh[i],	524	gfs2_buffer_copy_tail(mp->mp_bh[i],
525	sizeof(struct gfs2_meta_header),	525	sizeof(struct gfs2_meta_header),
526	dibh, sizeof(struct gfs2_dinode));	526	dibh, sizeof(struct gfs2_dinode));
527	gfs2_buffer_clear_tail(dibh,	527	gfs2_buffer_clear_tail(dibh,
528	sizeof(struct gfs2_dinode) +	528	sizeof(struct gfs2_dinode) +
529	sizeof(__be64));	529	sizeof(__be64));
530	ptr = (__be64 *)(mp->mp_bh[i]->b_data +	530	ptr = (__be64 *)(mp->mp_bh[i]->b_data +
531	sizeof(struct gfs2_meta_header));	531	sizeof(struct gfs2_meta_header));
532	*ptr = zero_bn;	532	*ptr = zero_bn;
533	state = ALLOC_GROW_DEPTH;	533	state = ALLOC_GROW_DEPTH;
534	for(i = branch_start; i < height; i++) {	534	for(i = branch_start; i < height; i++) {
535	if (mp->mp_bh[i] == NULL)	535	if (mp->mp_bh[i] == NULL)
536	break;	536	break;
537	brelse(mp->mp_bh[i]);	537	brelse(mp->mp_bh[i]);
538	mp->mp_bh[i] = NULL;	538	mp->mp_bh[i] = NULL;
539	}	539	}
540	i = branch_start;	540	i = branch_start;
541	}	541	}
542	if (n == 0)	542	if (n == 0)
543	break;	543	break;
544	/* Branching from existing tree */	544	/* Branching from existing tree */
545	case ALLOC_GROW_DEPTH:	545	case ALLOC_GROW_DEPTH:
546	if (i > 1 && i < height)	546	if (i > 1 && i < height)
547	gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[i-1], 1);	547	gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[i-1], 1);
548	for (; i < height && n > 0; i++, n--)	548	for (; i < height && n > 0; i++, n--)
549	gfs2_indirect_init(mp, ip->i_gl, i,	549	gfs2_indirect_init(mp, ip->i_gl, i,
550	mp->mp_list[i-1], bn++);	550	mp->mp_list[i-1], bn++);
551	if (i == height)	551	if (i == height)
552	state = ALLOC_DATA;	552	state = ALLOC_DATA;
553	if (n == 0)	553	if (n == 0)
554	break;	554	break;
555	/* Tree complete, adding data blocks */	555	/* Tree complete, adding data blocks */
556	case ALLOC_DATA:	556	case ALLOC_DATA:
557	BUG_ON(n > dblks);	557	BUG_ON(n > dblks);
558	BUG_ON(mp->mp_bh[end_of_metadata] == NULL);	558	BUG_ON(mp->mp_bh[end_of_metadata] == NULL);
559	gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[end_of_metadata], 1);	559	gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[end_of_metadata], 1);
560	dblks = n;	560	dblks = n;
561	ptr = metapointer(end_of_metadata, mp);	561	ptr = metapointer(end_of_metadata, mp);
562	dblock = bn;	562	dblock = bn;
563	while (n-- > 0)	563	while (n-- > 0)
564	*ptr++ = cpu_to_be64(bn++);	564	*ptr++ = cpu_to_be64(bn++);
565	if (buffer_zeronew(bh_map)) {	565	if (buffer_zeronew(bh_map)) {
566	ret = sb_issue_zeroout(sb, dblock, dblks,	566	ret = sb_issue_zeroout(sb, dblock, dblks,
567	GFP_NOFS);	567	GFP_NOFS);
568	if (ret) {	568	if (ret) {
569	fs_err(sdp,	569	fs_err(sdp,
570	"Failed to zero data buffers\n");	570	"Failed to zero data buffers\n");
571	clear_buffer_zeronew(bh_map);	571	clear_buffer_zeronew(bh_map);
572	}	572	}
573	}	573	}
574	break;	574	break;
575	}	575	}
576	} while ((state != ALLOC_DATA) \|\| !dblock);	576	} while ((state != ALLOC_DATA) \|\| !dblock);
577		577
578	ip->i_height = height;	578	ip->i_height = height;
579	gfs2_add_inode_blocks(&ip->i_inode, alloced);	579	gfs2_add_inode_blocks(&ip->i_inode, alloced);
580	gfs2_dinode_out(ip, mp->mp_bh[0]->b_data);	580	gfs2_dinode_out(ip, mp->mp_bh[0]->b_data);
581	map_bh(bh_map, inode->i_sb, dblock);	581	map_bh(bh_map, inode->i_sb, dblock);
582	bh_map->b_size = dblks << inode->i_blkbits;	582	bh_map->b_size = dblks << inode->i_blkbits;
583	set_buffer_new(bh_map);	583	set_buffer_new(bh_map);
584	return 0;	584	return 0;
585	}	585	}
586		586
587	/**	587	/**
588	* gfs2_block_map - Map a block from an inode to a disk block	588	* gfs2_block_map - Map a block from an inode to a disk block
589	* @inode: The inode	589	* @inode: The inode
590	* @lblock: The logical block number	590	* @lblock: The logical block number
591	* @bh_map: The bh to be mapped	591	* @bh_map: The bh to be mapped
592	* @create: True if its ok to alloc blocks to satify the request	592	* @create: True if its ok to alloc blocks to satify the request
593	*	593	*
594	* Sets buffer_mapped() if successful, sets buffer_boundary() if a	594	* Sets buffer_mapped() if successful, sets buffer_boundary() if a
595	* read of metadata will be required before the next block can be	595	* read of metadata will be required before the next block can be
596	* mapped. Sets buffer_new() if new blocks were allocated.	596	* mapped. Sets buffer_new() if new blocks were allocated.
597	*	597	*
598	* Returns: errno	598	* Returns: errno
599	*/	599	*/
600		600
601	int gfs2_block_map(struct inode *inode, sector_t lblock,	601	int gfs2_block_map(struct inode *inode, sector_t lblock,
602	struct buffer_head *bh_map, int create)	602	struct buffer_head *bh_map, int create)
603	{	603	{
604	struct gfs2_inode *ip = GFS2_I(inode);	604	struct gfs2_inode *ip = GFS2_I(inode);
605	struct gfs2_sbd *sdp = GFS2_SB(inode);	605	struct gfs2_sbd *sdp = GFS2_SB(inode);
606	unsigned int bsize = sdp->sd_sb.sb_bsize;	606	unsigned int bsize = sdp->sd_sb.sb_bsize;
607	const unsigned int maxlen = bh_map->b_size >> inode->i_blkbits;	607	const unsigned int maxlen = bh_map->b_size >> inode->i_blkbits;
608	const u64 *arr = sdp->sd_heightsize;	608	const u64 *arr = sdp->sd_heightsize;
609	__be64 *ptr;	609	__be64 *ptr;
610	u64 size;	610	u64 size;
611	struct metapath mp;	611	struct metapath mp;
612	int ret;	612	int ret;
613	int eob;	613	int eob;
614	unsigned int len;	614	unsigned int len;
615	struct buffer_head *bh;	615	struct buffer_head *bh;
616	u8 height;	616	u8 height;
617		617
618	BUG_ON(maxlen == 0);	618	BUG_ON(maxlen == 0);
619		619
620	memset(mp.mp_bh, 0, sizeof(mp.mp_bh));	620	memset(mp.mp_bh, 0, sizeof(mp.mp_bh));
621	bmap_lock(ip, create);	621	bmap_lock(ip, create);
622	clear_buffer_mapped(bh_map);	622	clear_buffer_mapped(bh_map);
623	clear_buffer_new(bh_map);	623	clear_buffer_new(bh_map);
624	clear_buffer_boundary(bh_map);	624	clear_buffer_boundary(bh_map);
625	trace_gfs2_bmap(ip, bh_map, lblock, create, 1);	625	trace_gfs2_bmap(ip, bh_map, lblock, create, 1);
626	if (gfs2_is_dir(ip)) {	626	if (gfs2_is_dir(ip)) {
627	bsize = sdp->sd_jbsize;	627	bsize = sdp->sd_jbsize;
628	arr = sdp->sd_jheightsize;	628	arr = sdp->sd_jheightsize;
629	}	629	}
630		630
631	ret = gfs2_meta_inode_buffer(ip, &mp.mp_bh[0]);	631	ret = gfs2_meta_inode_buffer(ip, &mp.mp_bh[0]);
632	if (ret)	632	if (ret)
633	goto out;	633	goto out;
634		634
635	height = ip->i_height;	635	height = ip->i_height;
636	size = (lblock + 1) * bsize;	636	size = (lblock + 1) * bsize;
637	while (size > arr[height])	637	while (size > arr[height])
638	height++;	638	height++;
639	find_metapath(sdp, lblock, &mp, height);	639	find_metapath(sdp, lblock, &mp, height);
640	ret = 1;	640	ret = 1;
641	if (height > ip->i_height \|\| gfs2_is_stuffed(ip))	641	if (height > ip->i_height \|\| gfs2_is_stuffed(ip))
642	goto do_alloc;	642	goto do_alloc;
643	ret = lookup_metapath(ip, &mp);	643	ret = lookup_metapath(ip, &mp);
644	if (ret < 0)	644	if (ret < 0)
645	goto out;	645	goto out;
646	if (ret != ip->i_height)	646	if (ret != ip->i_height)
647	goto do_alloc;	647	goto do_alloc;
648	ptr = metapointer(ip->i_height - 1, &mp);	648	ptr = metapointer(ip->i_height - 1, &mp);
649	if (*ptr == 0)	649	if (*ptr == 0)
650	goto do_alloc;	650	goto do_alloc;
651	map_bh(bh_map, inode->i_sb, be64_to_cpu(*ptr));	651	map_bh(bh_map, inode->i_sb, be64_to_cpu(*ptr));
652	bh = mp.mp_bh[ip->i_height - 1];	652	bh = mp.mp_bh[ip->i_height - 1];
653	len = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen, &eob);	653	len = gfs2_extent_length(bh->b_data, bh->b_size, ptr, maxlen, &eob);
654	bh_map->b_size = (len << inode->i_blkbits);	654	bh_map->b_size = (len << inode->i_blkbits);
655	if (eob)	655	if (eob)
656	set_buffer_boundary(bh_map);	656	set_buffer_boundary(bh_map);
657	ret = 0;	657	ret = 0;
658	out:	658	out:
659	release_metapath(&mp);	659	release_metapath(&mp);
660	trace_gfs2_bmap(ip, bh_map, lblock, create, ret);	660	trace_gfs2_bmap(ip, bh_map, lblock, create, ret);
661	bmap_unlock(ip, create);	661	bmap_unlock(ip, create);
662	return ret;	662	return ret;
663		663
664	do_alloc:	664	do_alloc:
665	/* All allocations are done here, firstly check create flag */	665	/* All allocations are done here, firstly check create flag */
666	if (!create) {	666	if (!create) {
667	BUG_ON(gfs2_is_stuffed(ip));	667	BUG_ON(gfs2_is_stuffed(ip));
668	ret = 0;	668	ret = 0;
669	goto out;	669	goto out;
670	}	670	}
671		671
672	/* At this point ret is the tree depth of already allocated blocks */	672	/* At this point ret is the tree depth of already allocated blocks */
673	ret = gfs2_bmap_alloc(inode, lblock, bh_map, &mp, ret, height, maxlen);	673	ret = gfs2_bmap_alloc(inode, lblock, bh_map, &mp, ret, height, maxlen);
674	goto out;	674	goto out;
675	}	675	}
676		676
677	/*	677	/*
678	* Deprecated: do not use in new code	678	* Deprecated: do not use in new code
679	*/	679	*/
680	int gfs2_extent_map(struct inode inode, u64 lblock, int new, u64 dblock, unsigned extlen)	680	int gfs2_extent_map(struct inode inode, u64 lblock, int new, u64 dblock, unsigned extlen)
681	{	681	{
682	struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 };	682	struct buffer_head bh = { .b_state = 0, .b_blocknr = 0 };
683	int ret;	683	int ret;
684	int create = *new;	684	int create = *new;
685		685
686	BUG_ON(!extlen);	686	BUG_ON(!extlen);
687	BUG_ON(!dblock);	687	BUG_ON(!dblock);
688	BUG_ON(!new);	688	BUG_ON(!new);
689		689
690	bh.b_size = 1 << (inode->i_blkbits + (create ? 0 : 5));	690	bh.b_size = 1 << (inode->i_blkbits + (create ? 0 : 5));
691	ret = gfs2_block_map(inode, lblock, &bh, create);	691	ret = gfs2_block_map(inode, lblock, &bh, create);
692	*extlen = bh.b_size >> inode->i_blkbits;	692	*extlen = bh.b_size >> inode->i_blkbits;
693	*dblock = bh.b_blocknr;	693	*dblock = bh.b_blocknr;
694	if (buffer_new(&bh))	694	if (buffer_new(&bh))
695	*new = 1;	695	*new = 1;
696	else	696	else
697	*new = 0;	697	*new = 0;
698	return ret;	698	return ret;
699	}	699	}
700		700
701	/**	701	/**
702	* do_strip - Look for a layer a particular layer of the file and strip it off	702	* do_strip - Look for a layer a particular layer of the file and strip it off
703	* @ip: the inode	703	* @ip: the inode
704	* @dibh: the dinode buffer	704	* @dibh: the dinode buffer
705	* @bh: A buffer of pointers	705	* @bh: A buffer of pointers
706	* @top: The first pointer in the buffer	706	* @top: The first pointer in the buffer
707	* @bottom: One more than the last pointer	707	* @bottom: One more than the last pointer
708	* @height: the height this buffer is at	708	* @height: the height this buffer is at
709	* @data: a pointer to a struct strip_mine	709	* @data: a pointer to a struct strip_mine
710	*	710	*
711	* Returns: errno	711	* Returns: errno
712	*/	712	*/
713		713
714	static int do_strip(struct gfs2_inode ip, struct buffer_head dibh,	714	static int do_strip(struct gfs2_inode ip, struct buffer_head dibh,
715	struct buffer_head bh, __be64 top, __be64 *bottom,	715	struct buffer_head bh, __be64 top, __be64 *bottom,
716	unsigned int height, struct strip_mine *sm)	716	unsigned int height, struct strip_mine *sm)
717	{	717	{
718	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	718	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
719	struct gfs2_rgrp_list rlist;	719	struct gfs2_rgrp_list rlist;
720	u64 bn, bstart;	720	u64 bn, bstart;
721	u32 blen, btotal;	721	u32 blen, btotal;
722	__be64 *p;	722	__be64 *p;
723	unsigned int rg_blocks = 0;	723	unsigned int rg_blocks = 0;
724	int metadata;	724	int metadata;
725	unsigned int revokes = 0;	725	unsigned int revokes = 0;
726	int x;	726	int x;
727	int error;	727	int error;
728		728
729	error = gfs2_rindex_update(sdp);	729	error = gfs2_rindex_update(sdp);
730	if (error)	730	if (error)
731	return error;	731	return error;
732		732
733	if (!*top)	733	if (!*top)
734	sm->sm_first = 0;	734	sm->sm_first = 0;
735		735
736	if (height != sm->sm_height)	736	if (height != sm->sm_height)
737	return 0;	737	return 0;
738		738
739	if (sm->sm_first) {	739	if (sm->sm_first) {
740	top++;	740	top++;
741	sm->sm_first = 0;	741	sm->sm_first = 0;
742	}	742	}
743		743
744	metadata = (height != ip->i_height - 1);	744	metadata = (height != ip->i_height - 1);
745	if (metadata)	745	if (metadata)
746	revokes = (height) ? sdp->sd_inptrs : sdp->sd_diptrs;	746	revokes = (height) ? sdp->sd_inptrs : sdp->sd_diptrs;
747	else if (ip->i_depth)	747	else if (ip->i_depth)
748	revokes = sdp->sd_inptrs;	748	revokes = sdp->sd_inptrs;
749		749
750	memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));	750	memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
751	bstart = 0;	751	bstart = 0;
752	blen = 0;	752	blen = 0;
753		753
754	for (p = top; p < bottom; p++) {	754	for (p = top; p < bottom; p++) {
755	if (!*p)	755	if (!*p)
756	continue;	756	continue;
757		757
758	bn = be64_to_cpu(*p);	758	bn = be64_to_cpu(*p);
759		759
760	if (bstart + blen == bn)	760	if (bstart + blen == bn)
761	blen++;	761	blen++;
762	else {	762	else {
763	if (bstart)	763	if (bstart)
764	gfs2_rlist_add(ip, &rlist, bstart);	764	gfs2_rlist_add(ip, &rlist, bstart);
765		765
766	bstart = bn;	766	bstart = bn;
767	blen = 1;	767	blen = 1;
768	}	768	}
769	}	769	}
770		770
771	if (bstart)	771	if (bstart)
772	gfs2_rlist_add(ip, &rlist, bstart);	772	gfs2_rlist_add(ip, &rlist, bstart);
773	else	773	else
774	goto out; /* Nothing to do */	774	goto out; /* Nothing to do */
775		775
776	gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);	776	gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
777		777
778	for (x = 0; x < rlist.rl_rgrps; x++) {	778	for (x = 0; x < rlist.rl_rgrps; x++) {
779	struct gfs2_rgrpd *rgd;	779	struct gfs2_rgrpd *rgd;
780	rgd = rlist.rl_ghs[x].gh_gl->gl_object;	780	rgd = rlist.rl_ghs[x].gh_gl->gl_object;
781	rg_blocks += rgd->rd_length;	781	rg_blocks += rgd->rd_length;
782	}	782	}
783		783
784	error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);	784	error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
785	if (error)	785	if (error)
786	goto out_rlist;	786	goto out_rlist;
787		787
788	if (gfs2_rs_active(ip->i_res)) /* needs to be done with the rgrp glock held */	788	if (gfs2_rs_active(ip->i_res)) /* needs to be done with the rgrp glock held */
789	gfs2_rs_deltree(ip, ip->i_res);	789	gfs2_rs_deltree(ip, ip->i_res);
790		790
791	error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE +	791	error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE +
792	RES_INDIRECT + RES_STATFS + RES_QUOTA,	792	RES_INDIRECT + RES_STATFS + RES_QUOTA,
793	revokes);	793	revokes);
794	if (error)	794	if (error)
795	goto out_rg_gunlock;	795	goto out_rg_gunlock;
796		796
797	down_write(&ip->i_rw_mutex);	797	down_write(&ip->i_rw_mutex);
798		798
799	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	799	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
800	gfs2_trans_add_bh(ip->i_gl, bh, 1);	800	gfs2_trans_add_bh(ip->i_gl, bh, 1);
801		801
802	bstart = 0;	802	bstart = 0;
803	blen = 0;	803	blen = 0;
804	btotal = 0;	804	btotal = 0;
805		805
806	for (p = top; p < bottom; p++) {	806	for (p = top; p < bottom; p++) {
807	if (!*p)	807	if (!*p)
808	continue;	808	continue;
809		809
810	bn = be64_to_cpu(*p);	810	bn = be64_to_cpu(*p);
811		811
812	if (bstart + blen == bn)	812	if (bstart + blen == bn)
813	blen++;	813	blen++;
814	else {	814	else {
815	if (bstart) {	815	if (bstart) {
816	__gfs2_free_blocks(ip, bstart, blen, metadata);	816	__gfs2_free_blocks(ip, bstart, blen, metadata);
817	btotal += blen;	817	btotal += blen;
818	}	818	}
819		819
820	bstart = bn;	820	bstart = bn;
821	blen = 1;	821	blen = 1;
822	}	822	}
823		823
824	*p = 0;	824	*p = 0;
825	gfs2_add_inode_blocks(&ip->i_inode, -1);	825	gfs2_add_inode_blocks(&ip->i_inode, -1);
826	}	826	}
827	if (bstart) {	827	if (bstart) {
828	__gfs2_free_blocks(ip, bstart, blen, metadata);	828	__gfs2_free_blocks(ip, bstart, blen, metadata);
829	btotal += blen;	829	btotal += blen;
830	}	830	}
831		831
832	gfs2_statfs_change(sdp, 0, +btotal, 0);	832	gfs2_statfs_change(sdp, 0, +btotal, 0);
833	gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid,	833	gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid,
834	ip->i_inode.i_gid);	834	ip->i_inode.i_gid);
835		835
836	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;	836	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
837		837
838	gfs2_dinode_out(ip, dibh->b_data);	838	gfs2_dinode_out(ip, dibh->b_data);
839		839
840	up_write(&ip->i_rw_mutex);	840	up_write(&ip->i_rw_mutex);
841		841
842	gfs2_trans_end(sdp);	842	gfs2_trans_end(sdp);
843		843
844	out_rg_gunlock:	844	out_rg_gunlock:
845	gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);	845	gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
846	out_rlist:	846	out_rlist:
847	gfs2_rlist_free(&rlist);	847	gfs2_rlist_free(&rlist);
848	out:	848	out:
849	return error;	849	return error;
850	}	850	}
851		851
852	/**	852	/**
853	* recursive_scan - recursively scan through the end of a file	853	* recursive_scan - recursively scan through the end of a file
854	* @ip: the inode	854	* @ip: the inode
855	* @dibh: the dinode buffer	855	* @dibh: the dinode buffer
856	* @mp: the path through the metadata to the point to start	856	* @mp: the path through the metadata to the point to start
857	* @height: the height the recursion is at	857	* @height: the height the recursion is at
858	* @block: the indirect block to look at	858	* @block: the indirect block to look at
859	* @first: 1 if this is the first block	859	* @first: 1 if this is the first block
860	* @sm: data opaque to this function to pass to @bc	860	* @sm: data opaque to this function to pass to @bc
861	*	861	*
862	* When this is first called @height and @block should be zero and	862	* When this is first called @height and @block should be zero and
863	* @first should be 1.	863	* @first should be 1.
864	*	864	*
865	* Returns: errno	865	* Returns: errno
866	*/	866	*/
867		867
868	static int recursive_scan(struct gfs2_inode ip, struct buffer_head dibh,	868	static int recursive_scan(struct gfs2_inode ip, struct buffer_head dibh,
869	struct metapath *mp, unsigned int height,	869	struct metapath *mp, unsigned int height,
870	u64 block, int first, struct strip_mine *sm)	870	u64 block, int first, struct strip_mine *sm)
871	{	871	{
872	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	872	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
873	struct buffer_head *bh = NULL;	873	struct buffer_head *bh = NULL;
874	__be64 top, bottom;	874	__be64 top, bottom;
875	u64 bn;	875	u64 bn;
876	int error;	876	int error;
877	int mh_size = sizeof(struct gfs2_meta_header);	877	int mh_size = sizeof(struct gfs2_meta_header);
878		878
879	if (!height) {	879	if (!height) {
880	error = gfs2_meta_inode_buffer(ip, &bh);	880	error = gfs2_meta_inode_buffer(ip, &bh);
881	if (error)	881	if (error)
882	return error;	882	return error;
883	dibh = bh;	883	dibh = bh;
884		884
885	top = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + mp->mp_list[0];	885	top = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + mp->mp_list[0];
886	bottom = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + sdp->sd_diptrs;	886	bottom = (__be64 *)(bh->b_data + sizeof(struct gfs2_dinode)) + sdp->sd_diptrs;
887	} else {	887	} else {
888	error = gfs2_meta_indirect_buffer(ip, height, block, &bh);	888	error = gfs2_meta_indirect_buffer(ip, height, block, &bh);
889	if (error)	889	if (error)
890	return error;	890	return error;
891		891
892	top = (__be64 *)(bh->b_data + mh_size) +	892	top = (__be64 *)(bh->b_data + mh_size) +
893	(first ? mp->mp_list[height] : 0);	893	(first ? mp->mp_list[height] : 0);
894		894
895	bottom = (__be64 *)(bh->b_data + mh_size) + sdp->sd_inptrs;	895	bottom = (__be64 *)(bh->b_data + mh_size) + sdp->sd_inptrs;
896	}	896	}
897		897
898	error = do_strip(ip, dibh, bh, top, bottom, height, sm);	898	error = do_strip(ip, dibh, bh, top, bottom, height, sm);
899	if (error)	899	if (error)
900	goto out;	900	goto out;
901		901
902	if (height < ip->i_height - 1) {	902	if (height < ip->i_height - 1) {
903		903
904	gfs2_metapath_ra(ip->i_gl, bh, top);	904	gfs2_metapath_ra(ip->i_gl, bh, top);
905		905
906	for (; top < bottom; top++, first = 0) {	906	for (; top < bottom; top++, first = 0) {
907	if (!*top)	907	if (!*top)
908	continue;	908	continue;
909		909
910	bn = be64_to_cpu(*top);	910	bn = be64_to_cpu(*top);
911		911
912	error = recursive_scan(ip, dibh, mp, height + 1, bn,	912	error = recursive_scan(ip, dibh, mp, height + 1, bn,
913	first, sm);	913	first, sm);
914	if (error)	914	if (error)
915	break;	915	break;
916	}	916	}
917	}	917	}
918	out:	918	out:
919	brelse(bh);	919	brelse(bh);
920	return error;	920	return error;
921	}	921	}
922		922
923		923
924	/**	924	/**
925	* gfs2_block_truncate_page - Deal with zeroing out data for truncate	925	* gfs2_block_truncate_page - Deal with zeroing out data for truncate
926	*	926	*
927	* This is partly borrowed from ext3.	927	* This is partly borrowed from ext3.
928	*/	928	*/
929	static int gfs2_block_truncate_page(struct address_space *mapping, loff_t from)	929	static int gfs2_block_truncate_page(struct address_space *mapping, loff_t from)
930	{	930	{
931	struct inode *inode = mapping->host;	931	struct inode *inode = mapping->host;
932	struct gfs2_inode *ip = GFS2_I(inode);	932	struct gfs2_inode *ip = GFS2_I(inode);
933	unsigned long index = from >> PAGE_CACHE_SHIFT;	933	unsigned long index = from >> PAGE_CACHE_SHIFT;
934	unsigned offset = from & (PAGE_CACHE_SIZE-1);	934	unsigned offset = from & (PAGE_CACHE_SIZE-1);
935	unsigned blocksize, iblock, length, pos;	935	unsigned blocksize, iblock, length, pos;
936	struct buffer_head *bh;	936	struct buffer_head *bh;
937	struct page *page;	937	struct page *page;
938	int err;	938	int err;
939		939
940	page = find_or_create_page(mapping, index, GFP_NOFS);	940	page = find_or_create_page(mapping, index, GFP_NOFS);
941	if (!page)	941	if (!page)
942	return 0;	942	return 0;
943		943
944	blocksize = inode->i_sb->s_blocksize;	944	blocksize = inode->i_sb->s_blocksize;
945	length = blocksize - (offset & (blocksize - 1));	945	length = blocksize - (offset & (blocksize - 1));
946	iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);	946	iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
947		947
948	if (!page_has_buffers(page))	948	if (!page_has_buffers(page))
949	create_empty_buffers(page, blocksize, 0);	949	create_empty_buffers(page, blocksize, 0);
950		950
951	/* Find the buffer that contains "offset" */	951	/* Find the buffer that contains "offset" */
952	bh = page_buffers(page);	952	bh = page_buffers(page);
953	pos = blocksize;	953	pos = blocksize;
954	while (offset >= pos) {	954	while (offset >= pos) {
955	bh = bh->b_this_page;	955	bh = bh->b_this_page;
956	iblock++;	956	iblock++;
957	pos += blocksize;	957	pos += blocksize;
958	}	958	}
959		959
960	err = 0;	960	err = 0;
961		961
962	if (!buffer_mapped(bh)) {	962	if (!buffer_mapped(bh)) {
963	gfs2_block_map(inode, iblock, bh, 0);	963	gfs2_block_map(inode, iblock, bh, 0);
964	/* unmapped? It's a hole - nothing to do */	964	/* unmapped? It's a hole - nothing to do */
965	if (!buffer_mapped(bh))	965	if (!buffer_mapped(bh))
966	goto unlock;	966	goto unlock;
967	}	967	}
968		968
969	/* Ok, it's mapped. Make sure it's up-to-date */	969	/* Ok, it's mapped. Make sure it's up-to-date */
970	if (PageUptodate(page))	970	if (PageUptodate(page))
971	set_buffer_uptodate(bh);	971	set_buffer_uptodate(bh);
972		972
973	if (!buffer_uptodate(bh)) {	973	if (!buffer_uptodate(bh)) {
974	err = -EIO;	974	err = -EIO;
975	ll_rw_block(READ, 1, &bh);	975	ll_rw_block(READ, 1, &bh);
976	wait_on_buffer(bh);	976	wait_on_buffer(bh);
977	/* Uhhuh. Read error. Complain and punt. */	977	/* Uhhuh. Read error. Complain and punt. */
978	if (!buffer_uptodate(bh))	978	if (!buffer_uptodate(bh))
979	goto unlock;	979	goto unlock;
980	err = 0;	980	err = 0;
981	}	981	}
982		982
983	if (!gfs2_is_writeback(ip))	983	if (!gfs2_is_writeback(ip))
984	gfs2_trans_add_bh(ip->i_gl, bh, 0);	984	gfs2_trans_add_bh(ip->i_gl, bh, 0);
985		985
986	zero_user(page, offset, length);	986	zero_user(page, offset, length);
987	mark_buffer_dirty(bh);	987	mark_buffer_dirty(bh);
988	unlock:	988	unlock:
989	unlock_page(page);	989	unlock_page(page);
990	page_cache_release(page);	990	page_cache_release(page);
991	return err;	991	return err;
992	}	992	}
993		993
994	static int trunc_start(struct inode *inode, u64 oldsize, u64 newsize)	994	static int trunc_start(struct inode *inode, u64 oldsize, u64 newsize)
995	{	995	{
996	struct gfs2_inode *ip = GFS2_I(inode);	996	struct gfs2_inode *ip = GFS2_I(inode);
997	struct gfs2_sbd *sdp = GFS2_SB(inode);	997	struct gfs2_sbd *sdp = GFS2_SB(inode);
998	struct address_space *mapping = inode->i_mapping;	998	struct address_space *mapping = inode->i_mapping;
999	struct buffer_head *dibh;	999	struct buffer_head *dibh;
1000	int journaled = gfs2_is_jdata(ip);	1000	int journaled = gfs2_is_jdata(ip);
1001	int error;	1001	int error;
1002		1002
1003	error = gfs2_trans_begin(sdp,	1003	error = gfs2_trans_begin(sdp,
1004	RES_DINODE + (journaled ? RES_JDATA : 0), 0);	1004	RES_DINODE + (journaled ? RES_JDATA : 0), 0);
1005	if (error)	1005	if (error)
1006	return error;	1006	return error;
1007		1007
1008	error = gfs2_meta_inode_buffer(ip, &dibh);	1008	error = gfs2_meta_inode_buffer(ip, &dibh);
1009	if (error)	1009	if (error)
1010	goto out;	1010	goto out;
1011		1011
1012	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	1012	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1013		1013
1014	if (gfs2_is_stuffed(ip)) {	1014	if (gfs2_is_stuffed(ip)) {
1015	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);	1015	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode) + newsize);
1016	} else {	1016	} else {
1017	if (newsize & (u64)(sdp->sd_sb.sb_bsize - 1)) {	1017	if (newsize & (u64)(sdp->sd_sb.sb_bsize - 1)) {
1018	error = gfs2_block_truncate_page(mapping, newsize);	1018	error = gfs2_block_truncate_page(mapping, newsize);
1019	if (error)	1019	if (error)
1020	goto out_brelse;	1020	goto out_brelse;
1021	}	1021	}
1022	ip->i_diskflags \|= GFS2_DIF_TRUNC_IN_PROG;	1022	ip->i_diskflags \|= GFS2_DIF_TRUNC_IN_PROG;
1023	}	1023	}
1024		1024
1025	i_size_write(inode, newsize);	1025	i_size_write(inode, newsize);
1026	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;	1026	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1027	gfs2_dinode_out(ip, dibh->b_data);	1027	gfs2_dinode_out(ip, dibh->b_data);
1028		1028
1029	truncate_pagecache(inode, oldsize, newsize);	1029	truncate_pagecache(inode, oldsize, newsize);
1030	out_brelse:	1030	out_brelse:
1031	brelse(dibh);	1031	brelse(dibh);
1032	out:	1032	out:
1033	gfs2_trans_end(sdp);	1033	gfs2_trans_end(sdp);
1034	return error;	1034	return error;
1035	}	1035	}
1036		1036
1037	static int trunc_dealloc(struct gfs2_inode *ip, u64 size)	1037	static int trunc_dealloc(struct gfs2_inode *ip, u64 size)
1038	{	1038	{
1039	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1039	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1040	unsigned int height = ip->i_height;	1040	unsigned int height = ip->i_height;
1041	u64 lblock;	1041	u64 lblock;
1042	struct metapath mp;	1042	struct metapath mp;
1043	int error;	1043	int error;
1044		1044
1045	if (!size)	1045	if (!size)
1046	lblock = 0;	1046	lblock = 0;
1047	else	1047	else
1048	lblock = (size - 1) >> sdp->sd_sb.sb_bsize_shift;	1048	lblock = (size - 1) >> sdp->sd_sb.sb_bsize_shift;
1049		1049
1050	find_metapath(sdp, lblock, &mp, ip->i_height);	1050	find_metapath(sdp, lblock, &mp, ip->i_height);
1051	error = gfs2_rindex_update(sdp);	1051	error = gfs2_rindex_update(sdp);
1052	if (error)	1052	if (error)
1053	return error;	1053	return error;
1054		1054
1055	error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);	1055	error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
1056	if (error)	1056	if (error)
1057	return error;	1057	return error;
1058		1058
1059	while (height--) {	1059	while (height--) {
1060	struct strip_mine sm;	1060	struct strip_mine sm;
1061	sm.sm_first = !!size;	1061	sm.sm_first = !!size;
1062	sm.sm_height = height;	1062	sm.sm_height = height;
1063		1063
1064	error = recursive_scan(ip, NULL, &mp, 0, 0, 1, &sm);	1064	error = recursive_scan(ip, NULL, &mp, 0, 0, 1, &sm);
1065	if (error)	1065	if (error)
1066	break;	1066	break;
1067	}	1067	}
1068		1068
1069	gfs2_quota_unhold(ip);	1069	gfs2_quota_unhold(ip);
1070		1070
1071	return error;	1071	return error;
1072	}	1072	}
1073		1073
1074	static int trunc_end(struct gfs2_inode *ip)	1074	static int trunc_end(struct gfs2_inode *ip)
1075	{	1075	{
1076	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1076	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1077	struct buffer_head *dibh;	1077	struct buffer_head *dibh;
1078	int error;	1078	int error;
1079		1079
1080	error = gfs2_trans_begin(sdp, RES_DINODE, 0);	1080	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
1081	if (error)	1081	if (error)
1082	return error;	1082	return error;
1083		1083
1084	down_write(&ip->i_rw_mutex);	1084	down_write(&ip->i_rw_mutex);
1085		1085
1086	error = gfs2_meta_inode_buffer(ip, &dibh);	1086	error = gfs2_meta_inode_buffer(ip, &dibh);
1087	if (error)	1087	if (error)
1088	goto out;	1088	goto out;
1089		1089
1090	if (!i_size_read(&ip->i_inode)) {	1090	if (!i_size_read(&ip->i_inode)) {
1091	ip->i_height = 0;	1091	ip->i_height = 0;
1092	ip->i_goal = ip->i_no_addr;	1092	ip->i_goal = ip->i_no_addr;
1093	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));	1093	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
1094	}	1094	}
1095	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;	1095	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1096	ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;	1096	ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
1097		1097
1098	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	1098	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1099	gfs2_dinode_out(ip, dibh->b_data);	1099	gfs2_dinode_out(ip, dibh->b_data);
1100	brelse(dibh);	1100	brelse(dibh);
1101		1101
1102	out:	1102	out:
1103	up_write(&ip->i_rw_mutex);	1103	up_write(&ip->i_rw_mutex);
1104	gfs2_trans_end(sdp);	1104	gfs2_trans_end(sdp);
1105	return error;	1105	return error;
1106	}	1106	}
1107		1107
1108	/**	1108	/**
1109	* do_shrink - make a file smaller	1109	* do_shrink - make a file smaller
1110	* @inode: the inode	1110	* @inode: the inode
1111	* @oldsize: the current inode size	1111	* @oldsize: the current inode size
1112	* @newsize: the size to make the file	1112	* @newsize: the size to make the file
1113	*	1113	*
1114	* Called with an exclusive lock on @inode. The @size must	1114	* Called with an exclusive lock on @inode. The @size must
1115	* be equal to or smaller than the current inode size.	1115	* be equal to or smaller than the current inode size.
1116	*	1116	*
1117	* Returns: errno	1117	* Returns: errno
1118	*/	1118	*/
1119		1119
1120	static int do_shrink(struct inode *inode, u64 oldsize, u64 newsize)	1120	static int do_shrink(struct inode *inode, u64 oldsize, u64 newsize)
1121	{	1121	{
1122	struct gfs2_inode *ip = GFS2_I(inode);	1122	struct gfs2_inode *ip = GFS2_I(inode);
1123	int error;	1123	int error;
1124		1124
1125	error = trunc_start(inode, oldsize, newsize);	1125	error = trunc_start(inode, oldsize, newsize);
1126	if (error < 0)	1126	if (error < 0)
1127	return error;	1127	return error;
1128	if (gfs2_is_stuffed(ip))	1128	if (gfs2_is_stuffed(ip))
1129	return 0;	1129	return 0;
1130		1130
1131	error = trunc_dealloc(ip, newsize);	1131	error = trunc_dealloc(ip, newsize);
1132	if (error == 0)	1132	if (error == 0)
1133	error = trunc_end(ip);	1133	error = trunc_end(ip);
1134		1134
1135	return error;	1135	return error;
1136	}	1136	}
1137		1137
1138	void gfs2_trim_blocks(struct inode *inode)	1138	void gfs2_trim_blocks(struct inode *inode)
1139	{	1139	{
1140	u64 size = inode->i_size;	1140	u64 size = inode->i_size;
1141	int ret;	1141	int ret;
1142		1142
1143	ret = do_shrink(inode, size, size);	1143	ret = do_shrink(inode, size, size);
1144	WARN_ON(ret != 0);	1144	WARN_ON(ret != 0);
1145	}	1145	}
1146		1146
1147	/**	1147	/**
1148	* do_grow - Touch and update inode size	1148	* do_grow - Touch and update inode size
1149	* @inode: The inode	1149	* @inode: The inode
1150	* @size: The new size	1150	* @size: The new size
1151	*	1151	*
1152	* This function updates the timestamps on the inode and	1152	* This function updates the timestamps on the inode and
1153	* may also increase the size of the inode. This function	1153	* may also increase the size of the inode. This function
1154	* must not be called with @size any smaller than the current	1154	* must not be called with @size any smaller than the current
1155	* inode size.	1155	* inode size.
1156	*	1156	*
1157	* Although it is not strictly required to unstuff files here,	1157	* Although it is not strictly required to unstuff files here,
1158	* earlier versions of GFS2 have a bug in the stuffed file reading	1158	* earlier versions of GFS2 have a bug in the stuffed file reading
1159	* code which will result in a buffer overrun if the size is larger	1159	* code which will result in a buffer overrun if the size is larger
1160	* than the max stuffed file size. In order to prevent this from	1160	* than the max stuffed file size. In order to prevent this from
1161	* occurring, such files are unstuffed, but in other cases we can	1161	* occurring, such files are unstuffed, but in other cases we can
1162	* just update the inode size directly.	1162	* just update the inode size directly.
1163	*	1163	*
1164	* Returns: 0 on success, or -ve on error	1164	* Returns: 0 on success, or -ve on error
1165	*/	1165	*/
1166		1166
1167	static int do_grow(struct inode *inode, u64 size)	1167	static int do_grow(struct inode *inode, u64 size)
1168	{	1168	{
1169	struct gfs2_inode *ip = GFS2_I(inode);	1169	struct gfs2_inode *ip = GFS2_I(inode);
1170	struct gfs2_sbd *sdp = GFS2_SB(inode);	1170	struct gfs2_sbd *sdp = GFS2_SB(inode);
1171	struct buffer_head *dibh;	1171	struct buffer_head *dibh;
1172	int error;	1172	int error;
1173	int unstuff = 0;	1173	int unstuff = 0;
1174		1174
1175	if (gfs2_is_stuffed(ip) &&	1175	if (gfs2_is_stuffed(ip) &&
1176	(size > (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)))) {	1176	(size > (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)))) {
1177	error = gfs2_quota_lock_check(ip);	1177	error = gfs2_quota_lock_check(ip);
1178	if (error)	1178	if (error)
1179	return error;	1179	return error;
1180		1180
1181	error = gfs2_inplace_reserve(ip, 1);	1181	error = gfs2_inplace_reserve(ip, 1, 0);
1182	if (error)	1182	if (error)
1183	goto do_grow_qunlock;	1183	goto do_grow_qunlock;
1184	unstuff = 1;	1184	unstuff = 1;
1185	}	1185	}
1186		1186
1187	error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT, 0);	1187	error = gfs2_trans_begin(sdp, RES_DINODE + RES_STATFS + RES_RG_BIT, 0);
1188	if (error)	1188	if (error)
1189	goto do_grow_release;	1189	goto do_grow_release;
1190		1190
1191	if (unstuff) {	1191	if (unstuff) {
1192	error = gfs2_unstuff_dinode(ip, NULL);	1192	error = gfs2_unstuff_dinode(ip, NULL);
1193	if (error)	1193	if (error)
1194	goto do_end_trans;	1194	goto do_end_trans;
1195	}	1195	}
1196		1196
1197	error = gfs2_meta_inode_buffer(ip, &dibh);	1197	error = gfs2_meta_inode_buffer(ip, &dibh);
1198	if (error)	1198	if (error)
1199	goto do_end_trans;	1199	goto do_end_trans;
1200		1200
1201	i_size_write(inode, size);	1201	i_size_write(inode, size);
1202	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;	1202	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1203	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	1203	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1204	gfs2_dinode_out(ip, dibh->b_data);	1204	gfs2_dinode_out(ip, dibh->b_data);
1205	brelse(dibh);	1205	brelse(dibh);
1206		1206
1207	do_end_trans:	1207	do_end_trans:
1208	gfs2_trans_end(sdp);	1208	gfs2_trans_end(sdp);
1209	do_grow_release:	1209	do_grow_release:
1210	if (unstuff) {	1210	if (unstuff) {
1211	gfs2_inplace_release(ip);	1211	gfs2_inplace_release(ip);
1212	do_grow_qunlock:	1212	do_grow_qunlock:
1213	gfs2_quota_unlock(ip);	1213	gfs2_quota_unlock(ip);
1214	}	1214	}
1215	return error;	1215	return error;
1216	}	1216	}
1217		1217
1218	/**	1218	/**
1219	* gfs2_setattr_size - make a file a given size	1219	* gfs2_setattr_size - make a file a given size
1220	* @inode: the inode	1220	* @inode: the inode
1221	* @newsize: the size to make the file	1221	* @newsize: the size to make the file
1222	*	1222	*
1223	* The file size can grow, shrink, or stay the same size. This	1223	* The file size can grow, shrink, or stay the same size. This
1224	* is called holding i_mutex and an exclusive glock on the inode	1224	* is called holding i_mutex and an exclusive glock on the inode
1225	* in question.	1225	* in question.
1226	*	1226	*
1227	* Returns: errno	1227	* Returns: errno
1228	*/	1228	*/
1229		1229
1230	int gfs2_setattr_size(struct inode *inode, u64 newsize)	1230	int gfs2_setattr_size(struct inode *inode, u64 newsize)
1231	{	1231	{
1232	int ret;	1232	int ret;
1233	u64 oldsize;	1233	u64 oldsize;
1234		1234
1235	BUG_ON(!S_ISREG(inode->i_mode));	1235	BUG_ON(!S_ISREG(inode->i_mode));
1236		1236
1237	ret = inode_newsize_ok(inode, newsize);	1237	ret = inode_newsize_ok(inode, newsize);
1238	if (ret)	1238	if (ret)
1239	return ret;	1239	return ret;
1240		1240
1241	inode_dio_wait(inode);	1241	inode_dio_wait(inode);
1242		1242
1243	oldsize = inode->i_size;	1243	oldsize = inode->i_size;
1244	if (newsize >= oldsize)	1244	if (newsize >= oldsize)
1245	return do_grow(inode, newsize);	1245	return do_grow(inode, newsize);
1246		1246
1247	return do_shrink(inode, oldsize, newsize);	1247	return do_shrink(inode, oldsize, newsize);
1248	}	1248	}
1249		1249
1250	int gfs2_truncatei_resume(struct gfs2_inode *ip)	1250	int gfs2_truncatei_resume(struct gfs2_inode *ip)
1251	{	1251	{
1252	int error;	1252	int error;
1253	error = trunc_dealloc(ip, i_size_read(&ip->i_inode));	1253	error = trunc_dealloc(ip, i_size_read(&ip->i_inode));
1254	if (!error)	1254	if (!error)
1255	error = trunc_end(ip);	1255	error = trunc_end(ip);
1256	return error;	1256	return error;
1257	}	1257	}
1258		1258
1259	int gfs2_file_dealloc(struct gfs2_inode *ip)	1259	int gfs2_file_dealloc(struct gfs2_inode *ip)
1260	{	1260	{
1261	return trunc_dealloc(ip, 0);	1261	return trunc_dealloc(ip, 0);
1262	}	1262	}
1263		1263
1264	/**	1264	/**
1265	* gfs2_write_alloc_required - figure out if a write will require an allocation	1265	* gfs2_write_alloc_required - figure out if a write will require an allocation
1266	* @ip: the file being written to	1266	* @ip: the file being written to
1267	* @offset: the offset to write to	1267	* @offset: the offset to write to
1268	* @len: the number of bytes being written	1268	* @len: the number of bytes being written
1269	*	1269	*
1270	* Returns: 1 if an alloc is required, 0 otherwise	1270	* Returns: 1 if an alloc is required, 0 otherwise
1271	*/	1271	*/
1272		1272
1273	int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,	1273	int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,
1274	unsigned int len)	1274	unsigned int len)
1275	{	1275	{
1276	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1276	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1277	struct buffer_head bh;	1277	struct buffer_head bh;
1278	unsigned int shift;	1278	unsigned int shift;
1279	u64 lblock, lblock_stop, size;	1279	u64 lblock, lblock_stop, size;
1280	u64 end_of_file;	1280	u64 end_of_file;
1281		1281
1282	if (!len)	1282	if (!len)
1283	return 0;	1283	return 0;
1284		1284
1285	if (gfs2_is_stuffed(ip)) {	1285	if (gfs2_is_stuffed(ip)) {
1286	if (offset + len >	1286	if (offset + len >
1287	sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))	1287	sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))
1288	return 1;	1288	return 1;
1289	return 0;	1289	return 0;
1290	}	1290	}
1291		1291
1292	shift = sdp->sd_sb.sb_bsize_shift;	1292	shift = sdp->sd_sb.sb_bsize_shift;
1293	BUG_ON(gfs2_is_dir(ip));	1293	BUG_ON(gfs2_is_dir(ip));
1294	end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift;	1294	end_of_file = (i_size_read(&ip->i_inode) + sdp->sd_sb.sb_bsize - 1) >> shift;
1295	lblock = offset >> shift;	1295	lblock = offset >> shift;
1296	lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;	1296	lblock_stop = (offset + len + sdp->sd_sb.sb_bsize - 1) >> shift;
1297	if (lblock_stop > end_of_file)	1297	if (lblock_stop > end_of_file)
1298	return 1;	1298	return 1;
1299		1299
1300	size = (lblock_stop - lblock) << shift;	1300	size = (lblock_stop - lblock) << shift;
1301	do {	1301	do {
1302	bh.b_state = 0;	1302	bh.b_state = 0;
1303	bh.b_size = size;	1303	bh.b_size = size;
1304	gfs2_block_map(&ip->i_inode, lblock, &bh, 0);	1304	gfs2_block_map(&ip->i_inode, lblock, &bh, 0);
1305	if (!buffer_mapped(&bh))	1305	if (!buffer_mapped(&bh))
1306	return 1;	1306	return 1;
1307	size -= bh.b_size;	1307	size -= bh.b_size;
1308	lblock += (bh.b_size >> ip->i_inode.i_blkbits);	1308	lblock += (bh.b_size >> ip->i_inode.i_blkbits);
1309	} while(size > 0);	1309	} while(size > 0);
1310		1310
1311	return 0;	1311	return 0;
1312	}	1312	}
1313		1313
1314		1314

fs/gfs2/file.c

Diff comments View file @ 9dbe961

1	/*	1	/*
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.	3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4	*	4	*
5	* This copyrighted material is made available to anyone wishing to use,	5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions	6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.	7	* of the GNU General Public License version 2.
8	*/	8	*/
9		9
10	#include <linux/slab.h>	10	#include <linux/slab.h>
11	#include <linux/spinlock.h>	11	#include <linux/spinlock.h>
12	#include <linux/completion.h>	12	#include <linux/completion.h>
13	#include <linux/buffer_head.h>	13	#include <linux/buffer_head.h>
14	#include <linux/pagemap.h>	14	#include <linux/pagemap.h>
15	#include <linux/uio.h>	15	#include <linux/uio.h>
16	#include <linux/blkdev.h>	16	#include <linux/blkdev.h>
17	#include <linux/mm.h>	17	#include <linux/mm.h>
18	#include <linux/mount.h>	18	#include <linux/mount.h>
19	#include <linux/fs.h>	19	#include <linux/fs.h>
20	#include <linux/gfs2_ondisk.h>	20	#include <linux/gfs2_ondisk.h>
21	#include <linux/falloc.h>	21	#include <linux/falloc.h>
22	#include <linux/swap.h>	22	#include <linux/swap.h>
23	#include <linux/crc32.h>	23	#include <linux/crc32.h>
24	#include <linux/writeback.h>	24	#include <linux/writeback.h>
25	#include <asm/uaccess.h>	25	#include <asm/uaccess.h>
26	#include <linux/dlm.h>	26	#include <linux/dlm.h>
27	#include <linux/dlm_plock.h>	27	#include <linux/dlm_plock.h>
28		28
29	#include "gfs2.h"	29	#include "gfs2.h"
30	#include "incore.h"	30	#include "incore.h"
31	#include "bmap.h"	31	#include "bmap.h"
32	#include "dir.h"	32	#include "dir.h"
33	#include "glock.h"	33	#include "glock.h"
34	#include "glops.h"	34	#include "glops.h"
35	#include "inode.h"	35	#include "inode.h"
36	#include "log.h"	36	#include "log.h"
37	#include "meta_io.h"	37	#include "meta_io.h"
38	#include "quota.h"	38	#include "quota.h"
39	#include "rgrp.h"	39	#include "rgrp.h"
40	#include "trans.h"	40	#include "trans.h"
41	#include "util.h"	41	#include "util.h"
42		42
43	/**	43	/**
44	* gfs2_llseek - seek to a location in a file	44	* gfs2_llseek - seek to a location in a file
45	* @file: the file	45	* @file: the file
46	* @offset: the offset	46	* @offset: the offset
47	* @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)	47	* @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
48	*	48	*
49	* SEEK_END requires the glock for the file because it references the	49	* SEEK_END requires the glock for the file because it references the
50	* file's size.	50	* file's size.
51	*	51	*
52	* Returns: The new offset, or errno	52	* Returns: The new offset, or errno
53	*/	53	*/
54		54
55	static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)	55	static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
56	{	56	{
57	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);	57	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
58	struct gfs2_holder i_gh;	58	struct gfs2_holder i_gh;
59	loff_t error;	59	loff_t error;
60		60
61	switch (origin) {	61	switch (origin) {
62	case SEEK_END: /* These reference inode->i_size */	62	case SEEK_END: /* These reference inode->i_size */
63	case SEEK_DATA:	63	case SEEK_DATA:
64	case SEEK_HOLE:	64	case SEEK_HOLE:
65	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,	65	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
66	&i_gh);	66	&i_gh);
67	if (!error) {	67	if (!error) {
68	error = generic_file_llseek(file, offset, origin);	68	error = generic_file_llseek(file, offset, origin);
69	gfs2_glock_dq_uninit(&i_gh);	69	gfs2_glock_dq_uninit(&i_gh);
70	}	70	}
71	break;	71	break;
72	case SEEK_CUR:	72	case SEEK_CUR:
73	case SEEK_SET:	73	case SEEK_SET:
74	error = generic_file_llseek(file, offset, origin);	74	error = generic_file_llseek(file, offset, origin);
75	break;	75	break;
76	default:	76	default:
77	error = -EINVAL;	77	error = -EINVAL;
78	}	78	}
79		79
80	return error;	80	return error;
81	}	81	}
82		82
83	/**	83	/**
84	* gfs2_readdir - Read directory entries from a directory	84	* gfs2_readdir - Read directory entries from a directory
85	* @file: The directory to read from	85	* @file: The directory to read from
86	* @dirent: Buffer for dirents	86	* @dirent: Buffer for dirents
87	* @filldir: Function used to do the copying	87	* @filldir: Function used to do the copying
88	*	88	*
89	* Returns: errno	89	* Returns: errno
90	*/	90	*/
91		91
92	static int gfs2_readdir(struct file file, void dirent, filldir_t filldir)	92	static int gfs2_readdir(struct file file, void dirent, filldir_t filldir)
93	{	93	{
94	struct inode *dir = file->f_mapping->host;	94	struct inode *dir = file->f_mapping->host;
95	struct gfs2_inode *dip = GFS2_I(dir);	95	struct gfs2_inode *dip = GFS2_I(dir);
96	struct gfs2_holder d_gh;	96	struct gfs2_holder d_gh;
97	u64 offset = file->f_pos;	97	u64 offset = file->f_pos;
98	int error;	98	int error;
99		99
100	gfs2_holder_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);	100	gfs2_holder_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
101	error = gfs2_glock_nq(&d_gh);	101	error = gfs2_glock_nq(&d_gh);
102	if (error) {	102	if (error) {
103	gfs2_holder_uninit(&d_gh);	103	gfs2_holder_uninit(&d_gh);
104	return error;	104	return error;
105	}	105	}
106		106
107	error = gfs2_dir_read(dir, &offset, dirent, filldir, &file->f_ra);	107	error = gfs2_dir_read(dir, &offset, dirent, filldir, &file->f_ra);
108		108
109	gfs2_glock_dq_uninit(&d_gh);	109	gfs2_glock_dq_uninit(&d_gh);
110		110
111	file->f_pos = offset;	111	file->f_pos = offset;
112		112
113	return error;	113	return error;
114	}	114	}
115		115
116	/**	116	/**
117	* fsflags_cvt	117	* fsflags_cvt
118	* @table: A table of 32 u32 flags	118	* @table: A table of 32 u32 flags
119	* @val: a 32 bit value to convert	119	* @val: a 32 bit value to convert
120	*	120	*
121	* This function can be used to convert between fsflags values and	121	* This function can be used to convert between fsflags values and
122	* GFS2's own flags values.	122	* GFS2's own flags values.
123	*	123	*
124	* Returns: the converted flags	124	* Returns: the converted flags
125	*/	125	*/
126	static u32 fsflags_cvt(const u32 *table, u32 val)	126	static u32 fsflags_cvt(const u32 *table, u32 val)
127	{	127	{
128	u32 res = 0;	128	u32 res = 0;
129	while(val) {	129	while(val) {
130	if (val & 1)	130	if (val & 1)
131	res \|= *table;	131	res \|= *table;
132	table++;	132	table++;
133	val >>= 1;	133	val >>= 1;
134	}	134	}
135	return res;	135	return res;
136	}	136	}
137		137
138	static const u32 fsflags_to_gfs2[32] = {	138	static const u32 fsflags_to_gfs2[32] = {
139	[3] = GFS2_DIF_SYNC,	139	[3] = GFS2_DIF_SYNC,
140	[4] = GFS2_DIF_IMMUTABLE,	140	[4] = GFS2_DIF_IMMUTABLE,
141	[5] = GFS2_DIF_APPENDONLY,	141	[5] = GFS2_DIF_APPENDONLY,
142	[7] = GFS2_DIF_NOATIME,	142	[7] = GFS2_DIF_NOATIME,
143	[12] = GFS2_DIF_EXHASH,	143	[12] = GFS2_DIF_EXHASH,
144	[14] = GFS2_DIF_INHERIT_JDATA,	144	[14] = GFS2_DIF_INHERIT_JDATA,
145	[17] = GFS2_DIF_TOPDIR,	145	[17] = GFS2_DIF_TOPDIR,
146	};	146	};
147		147
148	static const u32 gfs2_to_fsflags[32] = {	148	static const u32 gfs2_to_fsflags[32] = {
149	[gfs2fl_Sync] = FS_SYNC_FL,	149	[gfs2fl_Sync] = FS_SYNC_FL,
150	[gfs2fl_Immutable] = FS_IMMUTABLE_FL,	150	[gfs2fl_Immutable] = FS_IMMUTABLE_FL,
151	[gfs2fl_AppendOnly] = FS_APPEND_FL,	151	[gfs2fl_AppendOnly] = FS_APPEND_FL,
152	[gfs2fl_NoAtime] = FS_NOATIME_FL,	152	[gfs2fl_NoAtime] = FS_NOATIME_FL,
153	[gfs2fl_ExHash] = FS_INDEX_FL,	153	[gfs2fl_ExHash] = FS_INDEX_FL,
154	[gfs2fl_TopLevel] = FS_TOPDIR_FL,	154	[gfs2fl_TopLevel] = FS_TOPDIR_FL,
155	[gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL,	155	[gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL,
156	};	156	};
157		157
158	static int gfs2_get_flags(struct file filp, u32 __user ptr)	158	static int gfs2_get_flags(struct file filp, u32 __user ptr)
159	{	159	{
160	struct inode *inode = filp->f_path.dentry->d_inode;	160	struct inode *inode = filp->f_path.dentry->d_inode;
161	struct gfs2_inode *ip = GFS2_I(inode);	161	struct gfs2_inode *ip = GFS2_I(inode);
162	struct gfs2_holder gh;	162	struct gfs2_holder gh;
163	int error;	163	int error;
164	u32 fsflags;	164	u32 fsflags;
165		165
166	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);	166	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
167	error = gfs2_glock_nq(&gh);	167	error = gfs2_glock_nq(&gh);
168	if (error)	168	if (error)
169	return error;	169	return error;
170		170
171	fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_diskflags);	171	fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_diskflags);
172	if (!S_ISDIR(inode->i_mode) && ip->i_diskflags & GFS2_DIF_JDATA)	172	if (!S_ISDIR(inode->i_mode) && ip->i_diskflags & GFS2_DIF_JDATA)
173	fsflags \|= FS_JOURNAL_DATA_FL;	173	fsflags \|= FS_JOURNAL_DATA_FL;
174	if (put_user(fsflags, ptr))	174	if (put_user(fsflags, ptr))
175	error = -EFAULT;	175	error = -EFAULT;
176		176
177	gfs2_glock_dq(&gh);	177	gfs2_glock_dq(&gh);
178	gfs2_holder_uninit(&gh);	178	gfs2_holder_uninit(&gh);
179	return error;	179	return error;
180	}	180	}
181		181
182	void gfs2_set_inode_flags(struct inode *inode)	182	void gfs2_set_inode_flags(struct inode *inode)
183	{	183	{
184	struct gfs2_inode *ip = GFS2_I(inode);	184	struct gfs2_inode *ip = GFS2_I(inode);
185	unsigned int flags = inode->i_flags;	185	unsigned int flags = inode->i_flags;
186		186
187	flags &= ~(S_SYNC\|S_APPEND\|S_IMMUTABLE\|S_NOATIME\|S_DIRSYNC\|S_NOSEC);	187	flags &= ~(S_SYNC\|S_APPEND\|S_IMMUTABLE\|S_NOATIME\|S_DIRSYNC\|S_NOSEC);
188	if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode))	188	if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode))
189	inode->i_flags \|= S_NOSEC;	189	inode->i_flags \|= S_NOSEC;
190	if (ip->i_diskflags & GFS2_DIF_IMMUTABLE)	190	if (ip->i_diskflags & GFS2_DIF_IMMUTABLE)
191	flags \|= S_IMMUTABLE;	191	flags \|= S_IMMUTABLE;
192	if (ip->i_diskflags & GFS2_DIF_APPENDONLY)	192	if (ip->i_diskflags & GFS2_DIF_APPENDONLY)
193	flags \|= S_APPEND;	193	flags \|= S_APPEND;
194	if (ip->i_diskflags & GFS2_DIF_NOATIME)	194	if (ip->i_diskflags & GFS2_DIF_NOATIME)
195	flags \|= S_NOATIME;	195	flags \|= S_NOATIME;
196	if (ip->i_diskflags & GFS2_DIF_SYNC)	196	if (ip->i_diskflags & GFS2_DIF_SYNC)
197	flags \|= S_SYNC;	197	flags \|= S_SYNC;
198	inode->i_flags = flags;	198	inode->i_flags = flags;
199	}	199	}
200		200
201	/* Flags that can be set by user space */	201	/* Flags that can be set by user space */
202	#define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA\| \	202	#define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA\| \
203	GFS2_DIF_IMMUTABLE\| \	203	GFS2_DIF_IMMUTABLE\| \
204	GFS2_DIF_APPENDONLY\| \	204	GFS2_DIF_APPENDONLY\| \
205	GFS2_DIF_NOATIME\| \	205	GFS2_DIF_NOATIME\| \
206	GFS2_DIF_SYNC\| \	206	GFS2_DIF_SYNC\| \
207	GFS2_DIF_SYSTEM\| \	207	GFS2_DIF_SYSTEM\| \
208	GFS2_DIF_TOPDIR\| \	208	GFS2_DIF_TOPDIR\| \
209	GFS2_DIF_INHERIT_JDATA)	209	GFS2_DIF_INHERIT_JDATA)
210		210
211	/**	211	/**
212	* gfs2_set_flags - set flags on an inode	212	* gfs2_set_flags - set flags on an inode
213	* @inode: The inode	213	* @inode: The inode
214	* @flags: The flags to set	214	* @flags: The flags to set
215	* @mask: Indicates which flags are valid	215	* @mask: Indicates which flags are valid
216	*	216	*
217	*/	217	*/
218	static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)	218	static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
219	{	219	{
220	struct inode *inode = filp->f_path.dentry->d_inode;	220	struct inode *inode = filp->f_path.dentry->d_inode;
221	struct gfs2_inode *ip = GFS2_I(inode);	221	struct gfs2_inode *ip = GFS2_I(inode);
222	struct gfs2_sbd *sdp = GFS2_SB(inode);	222	struct gfs2_sbd *sdp = GFS2_SB(inode);
223	struct buffer_head *bh;	223	struct buffer_head *bh;
224	struct gfs2_holder gh;	224	struct gfs2_holder gh;
225	int error;	225	int error;
226	u32 new_flags, flags;	226	u32 new_flags, flags;
227		227
228	error = mnt_want_write_file(filp);	228	error = mnt_want_write_file(filp);
229	if (error)	229	if (error)
230	return error;	230	return error;
231		231
232	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);	232	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
233	if (error)	233	if (error)
234	goto out_drop_write;	234	goto out_drop_write;
235		235
236	error = -EACCES;	236	error = -EACCES;
237	if (!inode_owner_or_capable(inode))	237	if (!inode_owner_or_capable(inode))
238	goto out;	238	goto out;
239		239
240	error = 0;	240	error = 0;
241	flags = ip->i_diskflags;	241	flags = ip->i_diskflags;
242	new_flags = (flags & ~mask) \| (reqflags & mask);	242	new_flags = (flags & ~mask) \| (reqflags & mask);
243	if ((new_flags ^ flags) == 0)	243	if ((new_flags ^ flags) == 0)
244	goto out;	244	goto out;
245		245
246	error = -EINVAL;	246	error = -EINVAL;
247	if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET)	247	if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET)
248	goto out;	248	goto out;
249		249
250	error = -EPERM;	250	error = -EPERM;
251	if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE))	251	if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE))
252	goto out;	252	goto out;
253	if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY))	253	if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY))
254	goto out;	254	goto out;
255	if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&	255	if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
256	!capable(CAP_LINUX_IMMUTABLE))	256	!capable(CAP_LINUX_IMMUTABLE))
257	goto out;	257	goto out;
258	if (!IS_IMMUTABLE(inode)) {	258	if (!IS_IMMUTABLE(inode)) {
259	error = gfs2_permission(inode, MAY_WRITE);	259	error = gfs2_permission(inode, MAY_WRITE);
260	if (error)	260	if (error)
261	goto out;	261	goto out;
262	}	262	}
263	if ((flags ^ new_flags) & GFS2_DIF_JDATA) {	263	if ((flags ^ new_flags) & GFS2_DIF_JDATA) {
264	if (flags & GFS2_DIF_JDATA)	264	if (flags & GFS2_DIF_JDATA)
265	gfs2_log_flush(sdp, ip->i_gl);	265	gfs2_log_flush(sdp, ip->i_gl);
266	error = filemap_fdatawrite(inode->i_mapping);	266	error = filemap_fdatawrite(inode->i_mapping);
267	if (error)	267	if (error)
268	goto out;	268	goto out;
269	error = filemap_fdatawait(inode->i_mapping);	269	error = filemap_fdatawait(inode->i_mapping);
270	if (error)	270	if (error)
271	goto out;	271	goto out;
272	}	272	}
273	error = gfs2_trans_begin(sdp, RES_DINODE, 0);	273	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
274	if (error)	274	if (error)
275	goto out;	275	goto out;
276	error = gfs2_meta_inode_buffer(ip, &bh);	276	error = gfs2_meta_inode_buffer(ip, &bh);
277	if (error)	277	if (error)
278	goto out_trans_end;	278	goto out_trans_end;
279	gfs2_trans_add_bh(ip->i_gl, bh, 1);	279	gfs2_trans_add_bh(ip->i_gl, bh, 1);
280	ip->i_diskflags = new_flags;	280	ip->i_diskflags = new_flags;
281	gfs2_dinode_out(ip, bh->b_data);	281	gfs2_dinode_out(ip, bh->b_data);
282	brelse(bh);	282	brelse(bh);
283	gfs2_set_inode_flags(inode);	283	gfs2_set_inode_flags(inode);
284	gfs2_set_aops(inode);	284	gfs2_set_aops(inode);
285	out_trans_end:	285	out_trans_end:
286	gfs2_trans_end(sdp);	286	gfs2_trans_end(sdp);
287	out:	287	out:
288	gfs2_glock_dq_uninit(&gh);	288	gfs2_glock_dq_uninit(&gh);
289	out_drop_write:	289	out_drop_write:
290	mnt_drop_write_file(filp);	290	mnt_drop_write_file(filp);
291	return error;	291	return error;
292	}	292	}
293		293
294	static int gfs2_set_flags(struct file filp, u32 __user ptr)	294	static int gfs2_set_flags(struct file filp, u32 __user ptr)
295	{	295	{
296	struct inode *inode = filp->f_path.dentry->d_inode;	296	struct inode *inode = filp->f_path.dentry->d_inode;
297	u32 fsflags, gfsflags;	297	u32 fsflags, gfsflags;
298		298
299	if (get_user(fsflags, ptr))	299	if (get_user(fsflags, ptr))
300	return -EFAULT;	300	return -EFAULT;
301		301
302	gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);	302	gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);
303	if (!S_ISDIR(inode->i_mode)) {	303	if (!S_ISDIR(inode->i_mode)) {
304	gfsflags &= ~GFS2_DIF_TOPDIR;	304	gfsflags &= ~GFS2_DIF_TOPDIR;
305	if (gfsflags & GFS2_DIF_INHERIT_JDATA)	305	if (gfsflags & GFS2_DIF_INHERIT_JDATA)
306	gfsflags ^= (GFS2_DIF_JDATA \| GFS2_DIF_INHERIT_JDATA);	306	gfsflags ^= (GFS2_DIF_JDATA \| GFS2_DIF_INHERIT_JDATA);
307	return do_gfs2_set_flags(filp, gfsflags, ~0);	307	return do_gfs2_set_flags(filp, gfsflags, ~0);
308	}	308	}
309	return do_gfs2_set_flags(filp, gfsflags, ~GFS2_DIF_JDATA);	309	return do_gfs2_set_flags(filp, gfsflags, ~GFS2_DIF_JDATA);
310	}	310	}
311		311
312	static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)	312	static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
313	{	313	{
314	switch(cmd) {	314	switch(cmd) {
315	case FS_IOC_GETFLAGS:	315	case FS_IOC_GETFLAGS:
316	return gfs2_get_flags(filp, (u32 __user *)arg);	316	return gfs2_get_flags(filp, (u32 __user *)arg);
317	case FS_IOC_SETFLAGS:	317	case FS_IOC_SETFLAGS:
318	return gfs2_set_flags(filp, (u32 __user *)arg);	318	return gfs2_set_flags(filp, (u32 __user *)arg);
319	case FITRIM:	319	case FITRIM:
320	return gfs2_fitrim(filp, (void __user *)arg);	320	return gfs2_fitrim(filp, (void __user *)arg);
321	}	321	}
322	return -ENOTTY;	322	return -ENOTTY;
323	}	323	}
324		324
325	/**	325	/**
326	* gfs2_size_hint - Give a hint to the size of a write request	326	* gfs2_size_hint - Give a hint to the size of a write request
327	* @file: The struct file	327	* @file: The struct file
328	* @offset: The file offset of the write	328	* @offset: The file offset of the write
329	* @size: The length of the write	329	* @size: The length of the write
330	*	330	*
331	* When we are about to do a write, this function records the total	331	* When we are about to do a write, this function records the total
332	* write size in order to provide a suitable hint to the lower layers	332	* write size in order to provide a suitable hint to the lower layers
333	* about how many blocks will be required.	333	* about how many blocks will be required.
334	*	334	*
335	*/	335	*/
336		336
337	static void gfs2_size_hint(struct file *filep, loff_t offset, size_t size)	337	static void gfs2_size_hint(struct file *filep, loff_t offset, size_t size)
338	{	338	{
339	struct inode *inode = filep->f_dentry->d_inode;	339	struct inode *inode = filep->f_dentry->d_inode;
340	struct gfs2_sbd *sdp = GFS2_SB(inode);	340	struct gfs2_sbd *sdp = GFS2_SB(inode);
341	struct gfs2_inode *ip = GFS2_I(inode);	341	struct gfs2_inode *ip = GFS2_I(inode);
342	size_t blks = (size + sdp->sd_sb.sb_bsize - 1) >> sdp->sd_sb.sb_bsize_shift;	342	size_t blks = (size + sdp->sd_sb.sb_bsize - 1) >> sdp->sd_sb.sb_bsize_shift;
343	int hint = min_t(size_t, INT_MAX, blks);	343	int hint = min_t(size_t, INT_MAX, blks);
344		344
345	atomic_set(&ip->i_res->rs_sizehint, hint);	345	atomic_set(&ip->i_res->rs_sizehint, hint);
346	}	346	}
347		347
348	/**	348	/**
349	* gfs2_allocate_page_backing - Use bmap to allocate blocks	349	* gfs2_allocate_page_backing - Use bmap to allocate blocks
350	* @page: The (locked) page to allocate backing for	350	* @page: The (locked) page to allocate backing for
351	*	351	*
352	* We try to allocate all the blocks required for the page in	352	* We try to allocate all the blocks required for the page in
353	* one go. This might fail for various reasons, so we keep	353	* one go. This might fail for various reasons, so we keep
354	* trying until all the blocks to back this page are allocated.	354	* trying until all the blocks to back this page are allocated.
355	* If some of the blocks are already allocated, thats ok too.	355	* If some of the blocks are already allocated, thats ok too.
356	*/	356	*/
357		357
358	static int gfs2_allocate_page_backing(struct page *page)	358	static int gfs2_allocate_page_backing(struct page *page)
359	{	359	{
360	struct inode *inode = page->mapping->host;	360	struct inode *inode = page->mapping->host;
361	struct buffer_head bh;	361	struct buffer_head bh;
362	unsigned long size = PAGE_CACHE_SIZE;	362	unsigned long size = PAGE_CACHE_SIZE;
363	u64 lblock = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);	363	u64 lblock = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
364		364
365	do {	365	do {
366	bh.b_state = 0;	366	bh.b_state = 0;
367	bh.b_size = size;	367	bh.b_size = size;
368	gfs2_block_map(inode, lblock, &bh, 1);	368	gfs2_block_map(inode, lblock, &bh, 1);
369	if (!buffer_mapped(&bh))	369	if (!buffer_mapped(&bh))
370	return -EIO;	370	return -EIO;
371	size -= bh.b_size;	371	size -= bh.b_size;
372	lblock += (bh.b_size >> inode->i_blkbits);	372	lblock += (bh.b_size >> inode->i_blkbits);
373	} while(size > 0);	373	} while(size > 0);
374	return 0;	374	return 0;
375	}	375	}
376		376
377	/**	377	/**
378	* gfs2_page_mkwrite - Make a shared, mmap()ed, page writable	378	* gfs2_page_mkwrite - Make a shared, mmap()ed, page writable
379	* @vma: The virtual memory area	379	* @vma: The virtual memory area
380	* @page: The page which is about to become writable	380	* @page: The page which is about to become writable
381	*	381	*
382	* When the page becomes writable, we need to ensure that we have	382	* When the page becomes writable, we need to ensure that we have
383	* blocks allocated on disk to back that page.	383	* blocks allocated on disk to back that page.
384	*/	384	*/
385		385
386	static int gfs2_page_mkwrite(struct vm_area_struct vma, struct vm_fault vmf)	386	static int gfs2_page_mkwrite(struct vm_area_struct vma, struct vm_fault vmf)
387	{	387	{
388	struct page *page = vmf->page;	388	struct page *page = vmf->page;
389	struct inode *inode = vma->vm_file->f_path.dentry->d_inode;	389	struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
390	struct gfs2_inode *ip = GFS2_I(inode);	390	struct gfs2_inode *ip = GFS2_I(inode);
391	struct gfs2_sbd *sdp = GFS2_SB(inode);	391	struct gfs2_sbd *sdp = GFS2_SB(inode);
392	unsigned long last_index;	392	unsigned long last_index;
393	u64 pos = page->index << PAGE_CACHE_SHIFT;	393	u64 pos = page->index << PAGE_CACHE_SHIFT;
394	unsigned int data_blocks, ind_blocks, rblocks;	394	unsigned int data_blocks, ind_blocks, rblocks;
395	struct gfs2_holder gh;	395	struct gfs2_holder gh;
396	loff_t size;	396	loff_t size;
397	int ret;	397	int ret;
398		398
399	sb_start_pagefault(inode->i_sb);	399	sb_start_pagefault(inode->i_sb);
400		400
401	/* Update file times before taking page lock */	401	/* Update file times before taking page lock */
402	file_update_time(vma->vm_file);	402	file_update_time(vma->vm_file);
403		403
404	ret = gfs2_rs_alloc(ip);	404	ret = gfs2_rs_alloc(ip);
405	if (ret)	405	if (ret)
406	return ret;	406	return ret;
407		407
408	gfs2_size_hint(vma->vm_file, pos, PAGE_CACHE_SIZE);	408	gfs2_size_hint(vma->vm_file, pos, PAGE_CACHE_SIZE);
409		409
410	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);	410	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
411	ret = gfs2_glock_nq(&gh);	411	ret = gfs2_glock_nq(&gh);
412	if (ret)	412	if (ret)
413	goto out;	413	goto out;
414		414
415	set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);	415	set_bit(GLF_DIRTY, &ip->i_gl->gl_flags);
416	set_bit(GIF_SW_PAGED, &ip->i_flags);	416	set_bit(GIF_SW_PAGED, &ip->i_flags);
417		417
418	if (!gfs2_write_alloc_required(ip, pos, PAGE_CACHE_SIZE)) {	418	if (!gfs2_write_alloc_required(ip, pos, PAGE_CACHE_SIZE)) {
419	lock_page(page);	419	lock_page(page);
420	if (!PageUptodate(page) \|\| page->mapping != inode->i_mapping) {	420	if (!PageUptodate(page) \|\| page->mapping != inode->i_mapping) {
421	ret = -EAGAIN;	421	ret = -EAGAIN;
422	unlock_page(page);	422	unlock_page(page);
423	}	423	}
424	goto out_unlock;	424	goto out_unlock;
425	}	425	}
426		426
427	ret = gfs2_rindex_update(sdp);	427	ret = gfs2_rindex_update(sdp);
428	if (ret)	428	if (ret)
429	goto out_unlock;	429	goto out_unlock;
430		430
431	ret = gfs2_quota_lock_check(ip);	431	ret = gfs2_quota_lock_check(ip);
432	if (ret)	432	if (ret)
433	goto out_unlock;	433	goto out_unlock;
434	gfs2_write_calc_reserv(ip, PAGE_CACHE_SIZE, &data_blocks, &ind_blocks);	434	gfs2_write_calc_reserv(ip, PAGE_CACHE_SIZE, &data_blocks, &ind_blocks);
435	ret = gfs2_inplace_reserve(ip, data_blocks + ind_blocks);	435	ret = gfs2_inplace_reserve(ip, data_blocks + ind_blocks, 0);
436	if (ret)	436	if (ret)
437	goto out_quota_unlock;	437	goto out_quota_unlock;
438		438
439	rblocks = RES_DINODE + ind_blocks;	439	rblocks = RES_DINODE + ind_blocks;
440	if (gfs2_is_jdata(ip))	440	if (gfs2_is_jdata(ip))
441	rblocks += data_blocks ? data_blocks : 1;	441	rblocks += data_blocks ? data_blocks : 1;
442	if (ind_blocks \|\| data_blocks) {	442	if (ind_blocks \|\| data_blocks) {
443	rblocks += RES_STATFS + RES_QUOTA;	443	rblocks += RES_STATFS + RES_QUOTA;
444	rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks);	444	rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks);
445	}	445	}
446	ret = gfs2_trans_begin(sdp, rblocks, 0);	446	ret = gfs2_trans_begin(sdp, rblocks, 0);
447	if (ret)	447	if (ret)
448	goto out_trans_fail;	448	goto out_trans_fail;
449		449
450	lock_page(page);	450	lock_page(page);
451	ret = -EINVAL;	451	ret = -EINVAL;
452	size = i_size_read(inode);	452	size = i_size_read(inode);
453	last_index = (size - 1) >> PAGE_CACHE_SHIFT;	453	last_index = (size - 1) >> PAGE_CACHE_SHIFT;
454	/* Check page index against inode size */	454	/* Check page index against inode size */
455	if (size == 0 \|\| (page->index > last_index))	455	if (size == 0 \|\| (page->index > last_index))
456	goto out_trans_end;	456	goto out_trans_end;
457		457
458	ret = -EAGAIN;	458	ret = -EAGAIN;
459	/* If truncated, we must retry the operation, we may have raced	459	/* If truncated, we must retry the operation, we may have raced
460	* with the glock demotion code.	460	* with the glock demotion code.
461	*/	461	*/
462	if (!PageUptodate(page) \|\| page->mapping != inode->i_mapping)	462	if (!PageUptodate(page) \|\| page->mapping != inode->i_mapping)
463	goto out_trans_end;	463	goto out_trans_end;
464		464
465	/* Unstuff, if required, and allocate backing blocks for page */	465	/* Unstuff, if required, and allocate backing blocks for page */
466	ret = 0;	466	ret = 0;
467	if (gfs2_is_stuffed(ip))	467	if (gfs2_is_stuffed(ip))
468	ret = gfs2_unstuff_dinode(ip, page);	468	ret = gfs2_unstuff_dinode(ip, page);
469	if (ret == 0)	469	if (ret == 0)
470	ret = gfs2_allocate_page_backing(page);	470	ret = gfs2_allocate_page_backing(page);
471		471
472	out_trans_end:	472	out_trans_end:
473	if (ret)	473	if (ret)
474	unlock_page(page);	474	unlock_page(page);
475	gfs2_trans_end(sdp);	475	gfs2_trans_end(sdp);
476	out_trans_fail:	476	out_trans_fail:
477	gfs2_inplace_release(ip);	477	gfs2_inplace_release(ip);
478	out_quota_unlock:	478	out_quota_unlock:
479	gfs2_quota_unlock(ip);	479	gfs2_quota_unlock(ip);
480	out_unlock:	480	out_unlock:
481	gfs2_glock_dq(&gh);	481	gfs2_glock_dq(&gh);
482	out:	482	out:
483	gfs2_holder_uninit(&gh);	483	gfs2_holder_uninit(&gh);
484	if (ret == 0) {	484	if (ret == 0) {
485	set_page_dirty(page);	485	set_page_dirty(page);
486	wait_on_page_writeback(page);	486	wait_on_page_writeback(page);
487	}	487	}
488	sb_end_pagefault(inode->i_sb);	488	sb_end_pagefault(inode->i_sb);
489	return block_page_mkwrite_return(ret);	489	return block_page_mkwrite_return(ret);
490	}	490	}
491		491
492	static const struct vm_operations_struct gfs2_vm_ops = {	492	static const struct vm_operations_struct gfs2_vm_ops = {
493	.fault = filemap_fault,	493	.fault = filemap_fault,
494	.page_mkwrite = gfs2_page_mkwrite,	494	.page_mkwrite = gfs2_page_mkwrite,
495	.remap_pages = generic_file_remap_pages,	495	.remap_pages = generic_file_remap_pages,
496	};	496	};
497		497
498	/**	498	/**
499	* gfs2_mmap -	499	* gfs2_mmap -
500	* @file: The file to map	500	* @file: The file to map
501	* @vma: The VMA which described the mapping	501	* @vma: The VMA which described the mapping
502	*	502	*
503	* There is no need to get a lock here unless we should be updating	503	* There is no need to get a lock here unless we should be updating
504	* atime. We ignore any locking errors since the only consequence is	504	* atime. We ignore any locking errors since the only consequence is
505	* a missed atime update (which will just be deferred until later).	505	* a missed atime update (which will just be deferred until later).
506	*	506	*
507	* Returns: 0	507	* Returns: 0
508	*/	508	*/
509		509
510	static int gfs2_mmap(struct file file, struct vm_area_struct vma)	510	static int gfs2_mmap(struct file file, struct vm_area_struct vma)
511	{	511	{
512	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);	512	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
513		513
514	if (!(file->f_flags & O_NOATIME) &&	514	if (!(file->f_flags & O_NOATIME) &&
515	!IS_NOATIME(&ip->i_inode)) {	515	!IS_NOATIME(&ip->i_inode)) {
516	struct gfs2_holder i_gh;	516	struct gfs2_holder i_gh;
517	int error;	517	int error;
518		518
519	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,	519	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
520	&i_gh);	520	&i_gh);
521	if (error)	521	if (error)
522	return error;	522	return error;
523	/* grab lock to update inode */	523	/* grab lock to update inode */
524	gfs2_glock_dq_uninit(&i_gh);	524	gfs2_glock_dq_uninit(&i_gh);
525	file_accessed(file);	525	file_accessed(file);
526	}	526	}
527	vma->vm_ops = &gfs2_vm_ops;	527	vma->vm_ops = &gfs2_vm_ops;
528		528
529	return 0;	529	return 0;
530	}	530	}
531		531
532	/**	532	/**
533	* gfs2_open - open a file	533	* gfs2_open - open a file
534	* @inode: the inode to open	534	* @inode: the inode to open
535	* @file: the struct file for this opening	535	* @file: the struct file for this opening
536	*	536	*
537	* Returns: errno	537	* Returns: errno
538	*/	538	*/
539		539
540	static int gfs2_open(struct inode inode, struct file file)	540	static int gfs2_open(struct inode inode, struct file file)
541	{	541	{
542	struct gfs2_inode *ip = GFS2_I(inode);	542	struct gfs2_inode *ip = GFS2_I(inode);
543	struct gfs2_holder i_gh;	543	struct gfs2_holder i_gh;
544	struct gfs2_file *fp;	544	struct gfs2_file *fp;
545	int error;	545	int error;
546		546
547	fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);	547	fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
548	if (!fp)	548	if (!fp)
549	return -ENOMEM;	549	return -ENOMEM;
550		550
551	mutex_init(&fp->f_fl_mutex);	551	mutex_init(&fp->f_fl_mutex);
552		552
553	gfs2_assert_warn(GFS2_SB(inode), !file->private_data);	553	gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
554	file->private_data = fp;	554	file->private_data = fp;
555		555
556	if (S_ISREG(ip->i_inode.i_mode)) {	556	if (S_ISREG(ip->i_inode.i_mode)) {
557	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,	557	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
558	&i_gh);	558	&i_gh);
559	if (error)	559	if (error)
560	goto fail;	560	goto fail;
561		561
562	if (!(file->f_flags & O_LARGEFILE) &&	562	if (!(file->f_flags & O_LARGEFILE) &&
563	i_size_read(inode) > MAX_NON_LFS) {	563	i_size_read(inode) > MAX_NON_LFS) {
564	error = -EOVERFLOW;	564	error = -EOVERFLOW;
565	goto fail_gunlock;	565	goto fail_gunlock;
566	}	566	}
567		567
568	gfs2_glock_dq_uninit(&i_gh);	568	gfs2_glock_dq_uninit(&i_gh);
569	}	569	}
570		570
571	return 0;	571	return 0;
572		572
573	fail_gunlock:	573	fail_gunlock:
574	gfs2_glock_dq_uninit(&i_gh);	574	gfs2_glock_dq_uninit(&i_gh);
575	fail:	575	fail:
576	file->private_data = NULL;	576	file->private_data = NULL;
577	kfree(fp);	577	kfree(fp);
578	return error;	578	return error;
579	}	579	}
580		580
581	/**	581	/**
582	* gfs2_release - called to close a struct file	582	* gfs2_release - called to close a struct file
583	* @inode: the inode the struct file belongs to	583	* @inode: the inode the struct file belongs to
584	* @file: the struct file being closed	584	* @file: the struct file being closed
585	*	585	*
586	* Returns: errno	586	* Returns: errno
587	*/	587	*/
588		588
589	static int gfs2_release(struct inode inode, struct file file)	589	static int gfs2_release(struct inode inode, struct file file)
590	{	590	{
591	struct gfs2_inode *ip = GFS2_I(inode);	591	struct gfs2_inode *ip = GFS2_I(inode);
592		592
593	kfree(file->private_data);	593	kfree(file->private_data);
594	file->private_data = NULL;	594	file->private_data = NULL;
595		595
596	if ((file->f_mode & FMODE_WRITE) &&	596	if ((file->f_mode & FMODE_WRITE) &&
597	(atomic_read(&inode->i_writecount) == 1))	597	(atomic_read(&inode->i_writecount) == 1))
598	gfs2_rs_delete(ip);	598	gfs2_rs_delete(ip);
599		599
600	return 0;	600	return 0;
601	}	601	}
602		602
603	/**	603	/**
604	* gfs2_fsync - sync the dirty data for a file (across the cluster)	604	* gfs2_fsync - sync the dirty data for a file (across the cluster)
605	* @file: the file that points to the dentry	605	* @file: the file that points to the dentry
606	* @start: the start position in the file to sync	606	* @start: the start position in the file to sync
607	* @end: the end position in the file to sync	607	* @end: the end position in the file to sync
608	* @datasync: set if we can ignore timestamp changes	608	* @datasync: set if we can ignore timestamp changes
609	*	609	*
610	* We split the data flushing here so that we don't wait for the data	610	* We split the data flushing here so that we don't wait for the data
611	* until after we've also sent the metadata to disk. Note that for	611	* until after we've also sent the metadata to disk. Note that for
612	* data=ordered, we will write & wait for the data at the log flush	612	* data=ordered, we will write & wait for the data at the log flush
613	* stage anyway, so this is unlikely to make much of a difference	613	* stage anyway, so this is unlikely to make much of a difference
614	* except in the data=writeback case.	614	* except in the data=writeback case.
615	*	615	*
616	* If the fdatawrite fails due to any reason except -EIO, we will	616	* If the fdatawrite fails due to any reason except -EIO, we will
617	* continue the remainder of the fsync, although we'll still report	617	* continue the remainder of the fsync, although we'll still report
618	* the error at the end. This is to match filemap_write_and_wait_range()	618	* the error at the end. This is to match filemap_write_and_wait_range()
619	* behaviour.	619	* behaviour.
620	*	620	*
621	* Returns: errno	621	* Returns: errno
622	*/	622	*/
623		623
624	static int gfs2_fsync(struct file *file, loff_t start, loff_t end,	624	static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
625	int datasync)	625	int datasync)
626	{	626	{
627	struct address_space *mapping = file->f_mapping;	627	struct address_space *mapping = file->f_mapping;
628	struct inode *inode = mapping->host;	628	struct inode *inode = mapping->host;
629	int sync_state = inode->i_state & (I_DIRTY_SYNC\|I_DIRTY_DATASYNC);	629	int sync_state = inode->i_state & (I_DIRTY_SYNC\|I_DIRTY_DATASYNC);
630	struct gfs2_inode *ip = GFS2_I(inode);	630	struct gfs2_inode *ip = GFS2_I(inode);
631	int ret = 0, ret1 = 0;	631	int ret = 0, ret1 = 0;
632		632
633	if (mapping->nrpages) {	633	if (mapping->nrpages) {
634	ret1 = filemap_fdatawrite_range(mapping, start, end);	634	ret1 = filemap_fdatawrite_range(mapping, start, end);
635	if (ret1 == -EIO)	635	if (ret1 == -EIO)
636	return ret1;	636	return ret1;
637	}	637	}
638		638
639	if (datasync)	639	if (datasync)
640	sync_state &= ~I_DIRTY_SYNC;	640	sync_state &= ~I_DIRTY_SYNC;
641		641
642	if (sync_state) {	642	if (sync_state) {
643	ret = sync_inode_metadata(inode, 1);	643	ret = sync_inode_metadata(inode, 1);
644	if (ret)	644	if (ret)
645	return ret;	645	return ret;
646	if (gfs2_is_jdata(ip))	646	if (gfs2_is_jdata(ip))
647	filemap_write_and_wait(mapping);	647	filemap_write_and_wait(mapping);
648	gfs2_ail_flush(ip->i_gl, 1);	648	gfs2_ail_flush(ip->i_gl, 1);
649	}	649	}
650		650
651	if (mapping->nrpages)	651	if (mapping->nrpages)
652	ret = filemap_fdatawait_range(mapping, start, end);	652	ret = filemap_fdatawait_range(mapping, start, end);
653		653
654	return ret ? ret : ret1;	654	return ret ? ret : ret1;
655	}	655	}
656		656
657	/**	657	/**
658	* gfs2_file_aio_write - Perform a write to a file	658	* gfs2_file_aio_write - Perform a write to a file
659	* @iocb: The io context	659	* @iocb: The io context
660	* @iov: The data to write	660	* @iov: The data to write
661	* @nr_segs: Number of @iov segments	661	* @nr_segs: Number of @iov segments
662	* @pos: The file position	662	* @pos: The file position
663	*	663	*
664	* We have to do a lock/unlock here to refresh the inode size for	664	* We have to do a lock/unlock here to refresh the inode size for
665	* O_APPEND writes, otherwise we can land up writing at the wrong	665	* O_APPEND writes, otherwise we can land up writing at the wrong
666	* offset. There is still a race, but provided the app is using its	666	* offset. There is still a race, but provided the app is using its
667	* own file locking, this will make O_APPEND work as expected.	667	* own file locking, this will make O_APPEND work as expected.
668	*	668	*
669	*/	669	*/
670		670
671	static ssize_t gfs2_file_aio_write(struct kiocb iocb, const struct iovec iov,	671	static ssize_t gfs2_file_aio_write(struct kiocb iocb, const struct iovec iov,
672	unsigned long nr_segs, loff_t pos)	672	unsigned long nr_segs, loff_t pos)
673	{	673	{
674	struct file *file = iocb->ki_filp;	674	struct file *file = iocb->ki_filp;
675	size_t writesize = iov_length(iov, nr_segs);	675	size_t writesize = iov_length(iov, nr_segs);
676	struct dentry *dentry = file->f_dentry;	676	struct dentry *dentry = file->f_dentry;
677	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);	677	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
678	int ret;	678	int ret;
679		679
680	ret = gfs2_rs_alloc(ip);	680	ret = gfs2_rs_alloc(ip);
681	if (ret)	681	if (ret)
682	return ret;	682	return ret;
683		683
684	gfs2_size_hint(file, pos, writesize);	684	gfs2_size_hint(file, pos, writesize);
685		685
686	if (file->f_flags & O_APPEND) {	686	if (file->f_flags & O_APPEND) {
687	struct gfs2_holder gh;	687	struct gfs2_holder gh;
688		688
689	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);	689	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
690	if (ret)	690	if (ret)
691	return ret;	691	return ret;
692	gfs2_glock_dq_uninit(&gh);	692	gfs2_glock_dq_uninit(&gh);
693	}	693	}
694		694
695	return generic_file_aio_write(iocb, iov, nr_segs, pos);	695	return generic_file_aio_write(iocb, iov, nr_segs, pos);
696	}	696	}
697		697
698	static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,	698	static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,
699	int mode)	699	int mode)
700	{	700	{
701	struct gfs2_inode *ip = GFS2_I(inode);	701	struct gfs2_inode *ip = GFS2_I(inode);
702	struct buffer_head *dibh;	702	struct buffer_head *dibh;
703	int error;	703	int error;
704	loff_t size = len;	704	loff_t size = len;
705	unsigned int nr_blks;	705	unsigned int nr_blks;
706	sector_t lblock = offset >> inode->i_blkbits;	706	sector_t lblock = offset >> inode->i_blkbits;
707		707
708	error = gfs2_meta_inode_buffer(ip, &dibh);	708	error = gfs2_meta_inode_buffer(ip, &dibh);
709	if (unlikely(error))	709	if (unlikely(error))
710	return error;	710	return error;
711		711
712	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	712	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
713		713
714	if (gfs2_is_stuffed(ip)) {	714	if (gfs2_is_stuffed(ip)) {
715	error = gfs2_unstuff_dinode(ip, NULL);	715	error = gfs2_unstuff_dinode(ip, NULL);
716	if (unlikely(error))	716	if (unlikely(error))
717	goto out;	717	goto out;
718	}	718	}
719		719
720	while (len) {	720	while (len) {
721	struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };	721	struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
722	bh_map.b_size = len;	722	bh_map.b_size = len;
723	set_buffer_zeronew(&bh_map);	723	set_buffer_zeronew(&bh_map);
724		724
725	error = gfs2_block_map(inode, lblock, &bh_map, 1);	725	error = gfs2_block_map(inode, lblock, &bh_map, 1);
726	if (unlikely(error))	726	if (unlikely(error))
727	goto out;	727	goto out;
728	len -= bh_map.b_size;	728	len -= bh_map.b_size;
729	nr_blks = bh_map.b_size >> inode->i_blkbits;	729	nr_blks = bh_map.b_size >> inode->i_blkbits;
730	lblock += nr_blks;	730	lblock += nr_blks;
731	if (!buffer_new(&bh_map))	731	if (!buffer_new(&bh_map))
732	continue;	732	continue;
733	if (unlikely(!buffer_zeronew(&bh_map))) {	733	if (unlikely(!buffer_zeronew(&bh_map))) {
734	error = -EIO;	734	error = -EIO;
735	goto out;	735	goto out;
736	}	736	}
737	}	737	}
738	if (offset + size > inode->i_size && !(mode & FALLOC_FL_KEEP_SIZE))	738	if (offset + size > inode->i_size && !(mode & FALLOC_FL_KEEP_SIZE))
739	i_size_write(inode, offset + size);	739	i_size_write(inode, offset + size);
740		740
741	mark_inode_dirty(inode);	741	mark_inode_dirty(inode);
742		742
743	out:	743	out:
744	brelse(dibh);	744	brelse(dibh);
745	return error;	745	return error;
746	}	746	}
747		747
748	static void calc_max_reserv(struct gfs2_inode ip, loff_t max, loff_t len,	748	static void calc_max_reserv(struct gfs2_inode ip, loff_t max, loff_t len,
749	unsigned int data_blocks, unsigned int ind_blocks)	749	unsigned int data_blocks, unsigned int ind_blocks)
750	{	750	{
751	const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	751	const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
752	unsigned int max_blocks = ip->i_rgd->rd_free_clone;	752	unsigned int max_blocks = ip->i_rgd->rd_free_clone;
753	unsigned int tmp, max_data = max_blocks - 3 * (sdp->sd_max_height - 1);	753	unsigned int tmp, max_data = max_blocks - 3 * (sdp->sd_max_height - 1);
754		754
755	for (tmp = max_data; tmp > sdp->sd_diptrs;) {	755	for (tmp = max_data; tmp > sdp->sd_diptrs;) {
756	tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);	756	tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);
757	max_data -= tmp;	757	max_data -= tmp;
758	}	758	}
759	/* This calculation isn't the exact reverse of gfs2_write_calc_reserve,	759	/* This calculation isn't the exact reverse of gfs2_write_calc_reserve,
760	so it might end up with fewer data blocks */	760	so it might end up with fewer data blocks */
761	if (max_data <= *data_blocks)	761	if (max_data <= *data_blocks)
762	return;	762	return;
763	*data_blocks = max_data;	763	*data_blocks = max_data;
764	*ind_blocks = max_blocks - max_data;	764	*ind_blocks = max_blocks - max_data;
765	*len = ((loff_t)max_data - 3) << sdp->sd_sb.sb_bsize_shift;	765	*len = ((loff_t)max_data - 3) << sdp->sd_sb.sb_bsize_shift;
766	if (*len > max) {	766	if (*len > max) {
767	*len = max;	767	*len = max;
768	gfs2_write_calc_reserv(ip, max, data_blocks, ind_blocks);	768	gfs2_write_calc_reserv(ip, max, data_blocks, ind_blocks);
769	}	769	}
770	}	770	}
771		771
772	static long gfs2_fallocate(struct file *file, int mode, loff_t offset,	772	static long gfs2_fallocate(struct file *file, int mode, loff_t offset,
773	loff_t len)	773	loff_t len)
774	{	774	{
775	struct inode *inode = file->f_path.dentry->d_inode;	775	struct inode *inode = file->f_path.dentry->d_inode;
776	struct gfs2_sbd *sdp = GFS2_SB(inode);	776	struct gfs2_sbd *sdp = GFS2_SB(inode);
777	struct gfs2_inode *ip = GFS2_I(inode);	777	struct gfs2_inode *ip = GFS2_I(inode);
778	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;	778	unsigned int data_blocks = 0, ind_blocks = 0, rblocks;
779	loff_t bytes, max_bytes;	779	loff_t bytes, max_bytes;
780	int error;	780	int error;
781	const loff_t pos = offset;	781	const loff_t pos = offset;
782	const loff_t count = len;	782	const loff_t count = len;
783	loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1);	783	loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1);
784	loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift;	784	loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift;
785	loff_t max_chunk_size = UINT_MAX & bsize_mask;	785	loff_t max_chunk_size = UINT_MAX & bsize_mask;
786	next = (next + 1) << sdp->sd_sb.sb_bsize_shift;	786	next = (next + 1) << sdp->sd_sb.sb_bsize_shift;
787		787
788	/* We only support the FALLOC_FL_KEEP_SIZE mode */	788	/* We only support the FALLOC_FL_KEEP_SIZE mode */
789	if (mode & ~FALLOC_FL_KEEP_SIZE)	789	if (mode & ~FALLOC_FL_KEEP_SIZE)
790	return -EOPNOTSUPP;	790	return -EOPNOTSUPP;
791		791
792	offset &= bsize_mask;	792	offset &= bsize_mask;
793		793
794	len = next - offset;	794	len = next - offset;
795	bytes = sdp->sd_max_rg_data * sdp->sd_sb.sb_bsize / 2;	795	bytes = sdp->sd_max_rg_data * sdp->sd_sb.sb_bsize / 2;
796	if (!bytes)	796	if (!bytes)
797	bytes = UINT_MAX;	797	bytes = UINT_MAX;
798	bytes &= bsize_mask;	798	bytes &= bsize_mask;
799	if (bytes == 0)	799	if (bytes == 0)
800	bytes = sdp->sd_sb.sb_bsize;	800	bytes = sdp->sd_sb.sb_bsize;
801		801
802	error = gfs2_rs_alloc(ip);	802	error = gfs2_rs_alloc(ip);
803	if (error)	803	if (error)
804	return error;	804	return error;
805		805
806	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);	806	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &ip->i_gh);
807	error = gfs2_glock_nq(&ip->i_gh);	807	error = gfs2_glock_nq(&ip->i_gh);
808	if (unlikely(error))	808	if (unlikely(error))
809	goto out_uninit;	809	goto out_uninit;
810		810
811	gfs2_size_hint(file, offset, len);	811	gfs2_size_hint(file, offset, len);
812		812
813	while (len > 0) {	813	while (len > 0) {
814	if (len < bytes)	814	if (len < bytes)
815	bytes = len;	815	bytes = len;
816	if (!gfs2_write_alloc_required(ip, offset, bytes)) {	816	if (!gfs2_write_alloc_required(ip, offset, bytes)) {
817	len -= bytes;	817	len -= bytes;
818	offset += bytes;	818	offset += bytes;
819	continue;	819	continue;
820	}	820	}
821	error = gfs2_quota_lock_check(ip);	821	error = gfs2_quota_lock_check(ip);
822	if (error)	822	if (error)
823	goto out_unlock;	823	goto out_unlock;
824		824
825	retry:	825	retry:
826	gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks);	826	gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks);
827		827
828	error = gfs2_inplace_reserve(ip, data_blocks + ind_blocks);	828	error = gfs2_inplace_reserve(ip, data_blocks + ind_blocks, 0);
829	if (error) {	829	if (error) {
830	if (error == -ENOSPC && bytes > sdp->sd_sb.sb_bsize) {	830	if (error == -ENOSPC && bytes > sdp->sd_sb.sb_bsize) {
831	bytes >>= 1;	831	bytes >>= 1;
832	bytes &= bsize_mask;	832	bytes &= bsize_mask;
833	if (bytes == 0)	833	if (bytes == 0)
834	bytes = sdp->sd_sb.sb_bsize;	834	bytes = sdp->sd_sb.sb_bsize;
835	goto retry;	835	goto retry;
836	}	836	}
837	goto out_qunlock;	837	goto out_qunlock;
838	}	838	}
839	max_bytes = bytes;	839	max_bytes = bytes;
840	calc_max_reserv(ip, (len > max_chunk_size)? max_chunk_size: len,	840	calc_max_reserv(ip, (len > max_chunk_size)? max_chunk_size: len,
841	&max_bytes, &data_blocks, &ind_blocks);	841	&max_bytes, &data_blocks, &ind_blocks);
842		842
843	rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA +	843	rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA +
844	RES_RG_HDR + gfs2_rg_blocks(ip, data_blocks + ind_blocks);	844	RES_RG_HDR + gfs2_rg_blocks(ip, data_blocks + ind_blocks);
845	if (gfs2_is_jdata(ip))	845	if (gfs2_is_jdata(ip))
846	rblocks += data_blocks ? data_blocks : 1;	846	rblocks += data_blocks ? data_blocks : 1;
847		847
848	error = gfs2_trans_begin(sdp, rblocks,	848	error = gfs2_trans_begin(sdp, rblocks,
849	PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);	849	PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
850	if (error)	850	if (error)
851	goto out_trans_fail;	851	goto out_trans_fail;
852		852
853	error = fallocate_chunk(inode, offset, max_bytes, mode);	853	error = fallocate_chunk(inode, offset, max_bytes, mode);
854	gfs2_trans_end(sdp);	854	gfs2_trans_end(sdp);
855		855
856	if (error)	856	if (error)
857	goto out_trans_fail;	857	goto out_trans_fail;
858		858
859	len -= max_bytes;	859	len -= max_bytes;
860	offset += max_bytes;	860	offset += max_bytes;
861	gfs2_inplace_release(ip);	861	gfs2_inplace_release(ip);
862	gfs2_quota_unlock(ip);	862	gfs2_quota_unlock(ip);
863	}	863	}
864		864
865	if (error == 0)	865	if (error == 0)
866	error = generic_write_sync(file, pos, count);	866	error = generic_write_sync(file, pos, count);
867	goto out_unlock;	867	goto out_unlock;
868		868
869	out_trans_fail:	869	out_trans_fail:
870	gfs2_inplace_release(ip);	870	gfs2_inplace_release(ip);
871	out_qunlock:	871	out_qunlock:
872	gfs2_quota_unlock(ip);	872	gfs2_quota_unlock(ip);
873	out_unlock:	873	out_unlock:
874	gfs2_glock_dq(&ip->i_gh);	874	gfs2_glock_dq(&ip->i_gh);
875	out_uninit:	875	out_uninit:
876	gfs2_holder_uninit(&ip->i_gh);	876	gfs2_holder_uninit(&ip->i_gh);
877	return error;	877	return error;
878	}	878	}
879		879
880	#ifdef CONFIG_GFS2_FS_LOCKING_DLM	880	#ifdef CONFIG_GFS2_FS_LOCKING_DLM
881		881
882	/**	882	/**
883	* gfs2_setlease - acquire/release a file lease	883	* gfs2_setlease - acquire/release a file lease
884	* @file: the file pointer	884	* @file: the file pointer
885	* @arg: lease type	885	* @arg: lease type
886	* @fl: file lock	886	* @fl: file lock
887	*	887	*
888	* We don't currently have a way to enforce a lease across the whole	888	* We don't currently have a way to enforce a lease across the whole
889	* cluster; until we do, disable leases (by just returning -EINVAL),	889	* cluster; until we do, disable leases (by just returning -EINVAL),
890	* unless the administrator has requested purely local locking.	890	* unless the administrator has requested purely local locking.
891	*	891	*
892	* Locking: called under lock_flocks	892	* Locking: called under lock_flocks
893	*	893	*
894	* Returns: errno	894	* Returns: errno
895	*/	895	*/
896		896
897	static int gfs2_setlease(struct file file, long arg, struct file_lock *fl)	897	static int gfs2_setlease(struct file file, long arg, struct file_lock *fl)
898	{	898	{
899	return -EINVAL;	899	return -EINVAL;
900	}	900	}
901		901
902	/**	902	/**
903	* gfs2_lock - acquire/release a posix lock on a file	903	* gfs2_lock - acquire/release a posix lock on a file
904	* @file: the file pointer	904	* @file: the file pointer
905	* @cmd: either modify or retrieve lock state, possibly wait	905	* @cmd: either modify or retrieve lock state, possibly wait
906	* @fl: type and range of lock	906	* @fl: type and range of lock
907	*	907	*
908	* Returns: errno	908	* Returns: errno
909	*/	909	*/
910		910
911	static int gfs2_lock(struct file file, int cmd, struct file_lock fl)	911	static int gfs2_lock(struct file file, int cmd, struct file_lock fl)
912	{	912	{
913	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);	913	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
914	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);	914	struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
915	struct lm_lockstruct *ls = &sdp->sd_lockstruct;	915	struct lm_lockstruct *ls = &sdp->sd_lockstruct;
916		916
917	if (!(fl->fl_flags & FL_POSIX))	917	if (!(fl->fl_flags & FL_POSIX))
918	return -ENOLCK;	918	return -ENOLCK;
919	if (__mandatory_lock(&ip->i_inode) && fl->fl_type != F_UNLCK)	919	if (__mandatory_lock(&ip->i_inode) && fl->fl_type != F_UNLCK)
920	return -ENOLCK;	920	return -ENOLCK;
921		921
922	if (cmd == F_CANCELLK) {	922	if (cmd == F_CANCELLK) {
923	/* Hack: */	923	/* Hack: */
924	cmd = F_SETLK;	924	cmd = F_SETLK;
925	fl->fl_type = F_UNLCK;	925	fl->fl_type = F_UNLCK;
926	}	926	}
927	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))	927	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
928	return -EIO;	928	return -EIO;
929	if (IS_GETLK(cmd))	929	if (IS_GETLK(cmd))
930	return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl);	930	return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl);
931	else if (fl->fl_type == F_UNLCK)	931	else if (fl->fl_type == F_UNLCK)
932	return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl);	932	return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl);
933	else	933	else
934	return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl);	934	return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl);
935	}	935	}
936		936
937	static int do_flock(struct file file, int cmd, struct file_lock fl)	937	static int do_flock(struct file file, int cmd, struct file_lock fl)
938	{	938	{
939	struct gfs2_file *fp = file->private_data;	939	struct gfs2_file *fp = file->private_data;
940	struct gfs2_holder *fl_gh = &fp->f_fl_gh;	940	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
941	struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);	941	struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);
942	struct gfs2_glock *gl;	942	struct gfs2_glock *gl;
943	unsigned int state;	943	unsigned int state;
944	int flags;	944	int flags;
945	int error = 0;	945	int error = 0;
946		946
947	state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;	947	state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
948	flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) \| GL_EXACT \| GL_NOCACHE;	948	flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) \| GL_EXACT \| GL_NOCACHE;
949		949
950	mutex_lock(&fp->f_fl_mutex);	950	mutex_lock(&fp->f_fl_mutex);
951		951
952	gl = fl_gh->gh_gl;	952	gl = fl_gh->gh_gl;
953	if (gl) {	953	if (gl) {
954	if (fl_gh->gh_state == state)	954	if (fl_gh->gh_state == state)
955	goto out;	955	goto out;
956	flock_lock_file_wait(file,	956	flock_lock_file_wait(file,
957	&(struct file_lock){.fl_type = F_UNLCK});	957	&(struct file_lock){.fl_type = F_UNLCK});
958	gfs2_glock_dq_wait(fl_gh);	958	gfs2_glock_dq_wait(fl_gh);
959	gfs2_holder_reinit(state, flags, fl_gh);	959	gfs2_holder_reinit(state, flags, fl_gh);
960	} else {	960	} else {
961	error = gfs2_glock_get(GFS2_SB(&ip->i_inode), ip->i_no_addr,	961	error = gfs2_glock_get(GFS2_SB(&ip->i_inode), ip->i_no_addr,
962	&gfs2_flock_glops, CREATE, &gl);	962	&gfs2_flock_glops, CREATE, &gl);
963	if (error)	963	if (error)
964	goto out;	964	goto out;
965	gfs2_holder_init(gl, state, flags, fl_gh);	965	gfs2_holder_init(gl, state, flags, fl_gh);
966	gfs2_glock_put(gl);	966	gfs2_glock_put(gl);
967	}	967	}
968	error = gfs2_glock_nq(fl_gh);	968	error = gfs2_glock_nq(fl_gh);
969	if (error) {	969	if (error) {
970	gfs2_holder_uninit(fl_gh);	970	gfs2_holder_uninit(fl_gh);
971	if (error == GLR_TRYFAILED)	971	if (error == GLR_TRYFAILED)
972	error = -EAGAIN;	972	error = -EAGAIN;
973	} else {	973	} else {
974	error = flock_lock_file_wait(file, fl);	974	error = flock_lock_file_wait(file, fl);
975	gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);	975	gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
976	}	976	}
977		977
978	out:	978	out:
979	mutex_unlock(&fp->f_fl_mutex);	979	mutex_unlock(&fp->f_fl_mutex);
980	return error;	980	return error;
981	}	981	}
982		982
983	static void do_unflock(struct file file, struct file_lock fl)	983	static void do_unflock(struct file file, struct file_lock fl)
984	{	984	{
985	struct gfs2_file *fp = file->private_data;	985	struct gfs2_file *fp = file->private_data;
986	struct gfs2_holder *fl_gh = &fp->f_fl_gh;	986	struct gfs2_holder *fl_gh = &fp->f_fl_gh;
987		987
988	mutex_lock(&fp->f_fl_mutex);	988	mutex_lock(&fp->f_fl_mutex);
989	flock_lock_file_wait(file, fl);	989	flock_lock_file_wait(file, fl);
990	if (fl_gh->gh_gl) {	990	if (fl_gh->gh_gl) {
991	gfs2_glock_dq_wait(fl_gh);	991	gfs2_glock_dq_wait(fl_gh);
992	gfs2_holder_uninit(fl_gh);	992	gfs2_holder_uninit(fl_gh);
993	}	993	}
994	mutex_unlock(&fp->f_fl_mutex);	994	mutex_unlock(&fp->f_fl_mutex);
995	}	995	}
996		996
997	/**	997	/**
998	* gfs2_flock - acquire/release a flock lock on a file	998	* gfs2_flock - acquire/release a flock lock on a file
999	* @file: the file pointer	999	* @file: the file pointer
1000	* @cmd: either modify or retrieve lock state, possibly wait	1000	* @cmd: either modify or retrieve lock state, possibly wait
1001	* @fl: type and range of lock	1001	* @fl: type and range of lock
1002	*	1002	*
1003	* Returns: errno	1003	* Returns: errno
1004	*/	1004	*/
1005		1005
1006	static int gfs2_flock(struct file file, int cmd, struct file_lock fl)	1006	static int gfs2_flock(struct file file, int cmd, struct file_lock fl)
1007	{	1007	{
1008	if (!(fl->fl_flags & FL_FLOCK))	1008	if (!(fl->fl_flags & FL_FLOCK))
1009	return -ENOLCK;	1009	return -ENOLCK;
1010	if (fl->fl_type & LOCK_MAND)	1010	if (fl->fl_type & LOCK_MAND)
1011	return -EOPNOTSUPP;	1011	return -EOPNOTSUPP;
1012		1012
1013	if (fl->fl_type == F_UNLCK) {	1013	if (fl->fl_type == F_UNLCK) {
1014	do_unflock(file, fl);	1014	do_unflock(file, fl);
1015	return 0;	1015	return 0;
1016	} else {	1016	} else {
1017	return do_flock(file, cmd, fl);	1017	return do_flock(file, cmd, fl);
1018	}	1018	}
1019	}	1019	}
1020		1020
1021	const struct file_operations gfs2_file_fops = {	1021	const struct file_operations gfs2_file_fops = {
1022	.llseek = gfs2_llseek,	1022	.llseek = gfs2_llseek,
1023	.read = do_sync_read,	1023	.read = do_sync_read,
1024	.aio_read = generic_file_aio_read,	1024	.aio_read = generic_file_aio_read,
1025	.write = do_sync_write,	1025	.write = do_sync_write,
1026	.aio_write = gfs2_file_aio_write,	1026	.aio_write = gfs2_file_aio_write,
1027	.unlocked_ioctl = gfs2_ioctl,	1027	.unlocked_ioctl = gfs2_ioctl,
1028	.mmap = gfs2_mmap,	1028	.mmap = gfs2_mmap,
1029	.open = gfs2_open,	1029	.open = gfs2_open,
1030	.release = gfs2_release,	1030	.release = gfs2_release,
1031	.fsync = gfs2_fsync,	1031	.fsync = gfs2_fsync,
1032	.lock = gfs2_lock,	1032	.lock = gfs2_lock,
1033	.flock = gfs2_flock,	1033	.flock = gfs2_flock,
1034	.splice_read = generic_file_splice_read,	1034	.splice_read = generic_file_splice_read,
1035	.splice_write = generic_file_splice_write,	1035	.splice_write = generic_file_splice_write,
1036	.setlease = gfs2_setlease,	1036	.setlease = gfs2_setlease,
1037	.fallocate = gfs2_fallocate,	1037	.fallocate = gfs2_fallocate,
1038	};	1038	};
1039		1039
1040	const struct file_operations gfs2_dir_fops = {	1040	const struct file_operations gfs2_dir_fops = {
1041	.readdir = gfs2_readdir,	1041	.readdir = gfs2_readdir,
1042	.unlocked_ioctl = gfs2_ioctl,	1042	.unlocked_ioctl = gfs2_ioctl,
1043	.open = gfs2_open,	1043	.open = gfs2_open,
1044	.release = gfs2_release,	1044	.release = gfs2_release,
1045	.fsync = gfs2_fsync,	1045	.fsync = gfs2_fsync,
1046	.lock = gfs2_lock,	1046	.lock = gfs2_lock,
1047	.flock = gfs2_flock,	1047	.flock = gfs2_flock,
1048	.llseek = default_llseek,	1048	.llseek = default_llseek,
1049	};	1049	};
1050		1050
1051	#endif /* CONFIG_GFS2_FS_LOCKING_DLM */	1051	#endif /* CONFIG_GFS2_FS_LOCKING_DLM */
1052		1052
1053	const struct file_operations gfs2_file_fops_nolock = {	1053	const struct file_operations gfs2_file_fops_nolock = {
1054	.llseek = gfs2_llseek,	1054	.llseek = gfs2_llseek,
1055	.read = do_sync_read,	1055	.read = do_sync_read,
1056	.aio_read = generic_file_aio_read,	1056	.aio_read = generic_file_aio_read,
1057	.write = do_sync_write,	1057	.write = do_sync_write,
1058	.aio_write = gfs2_file_aio_write,	1058	.aio_write = gfs2_file_aio_write,
1059	.unlocked_ioctl = gfs2_ioctl,	1059	.unlocked_ioctl = gfs2_ioctl,
1060	.mmap = gfs2_mmap,	1060	.mmap = gfs2_mmap,
1061	.open = gfs2_open,	1061	.open = gfs2_open,
1062	.release = gfs2_release,	1062	.release = gfs2_release,
1063	.fsync = gfs2_fsync,	1063	.fsync = gfs2_fsync,
1064	.splice_read = generic_file_splice_read,	1064	.splice_read = generic_file_splice_read,
1065	.splice_write = generic_file_splice_write,	1065	.splice_write = generic_file_splice_write,
1066	.setlease = generic_setlease,	1066	.setlease = generic_setlease,
1067	.fallocate = gfs2_fallocate,	1067	.fallocate = gfs2_fallocate,
1068	};	1068	};
1069		1069
1070	const struct file_operations gfs2_dir_fops_nolock = {	1070	const struct file_operations gfs2_dir_fops_nolock = {
1071	.readdir = gfs2_readdir,	1071	.readdir = gfs2_readdir,
1072	.unlocked_ioctl = gfs2_ioctl,	1072	.unlocked_ioctl = gfs2_ioctl,
1073	.open = gfs2_open,	1073	.open = gfs2_open,
1074	.release = gfs2_release,	1074	.release = gfs2_release,
1075	.fsync = gfs2_fsync,	1075	.fsync = gfs2_fsync,
1076	.llseek = default_llseek,	1076	.llseek = default_llseek,
1077	};	1077	};
1078		1078
1079		1079

fs/gfs2/inode.c

Diff comments View file @ 9dbe961

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2011 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 version 2.
  */
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <linux/namei.h>
 #include <linux/mm.h>
 #include <linux/xattr.h>
 #include <linux/posix_acl.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
 #include <linux/fiemap.h>
 #include <linux/security.h>
 #include <asm/uaccess.h>
 #include "gfs2.h"
 #include "incore.h"
 #include "acl.h"
 #include "bmap.h"
 #include "dir.h"
 #include "xattr.h"
 #include "glock.h"
 #include "inode.h"
 #include "meta_io.h"
 #include "quota.h"
 #include "rgrp.h"
 #include "trans.h"
 #include "util.h"
 #include "super.h"
 #include "glops.h"
 struct gfs2_skip_data {
 	u64 no_addr;
 	int skipped;
 	int non_block;
 };
 static int iget_test(struct inode *inode, void *opaque)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_skip_data *data = opaque;
 	if (ip->i_no_addr == data->no_addr) {
 		if (data->non_block &&
 		    inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
 			data->skipped = 1;
 			return 0;
 		}
 		return 1;
 	}
 	return 0;
 }
 static int iget_set(struct inode *inode, void *opaque)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_skip_data *data = opaque;
 	if (data->skipped)
 		return -ENOENT;
 	inode->i_ino = (unsigned long)(data->no_addr);
 	ip->i_no_addr = data->no_addr;
 	return 0;
 }
 struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr, int non_block)
 {
 	unsigned long hash = (unsigned long)no_addr;
 	struct gfs2_skip_data data;
 	data.no_addr = no_addr;
 	data.skipped = 0;
 	data.non_block = non_block;
 	return ilookup5(sb, hash, iget_test, &data);
 }
 static struct inode *gfs2_iget(struct super_block *sb, u64 no_addr,
 			       int non_block)
 {
 	struct gfs2_skip_data data;
 	unsigned long hash = (unsigned long)no_addr;
 	data.no_addr = no_addr;
 	data.skipped = 0;
 	data.non_block = non_block;
 	return iget5_locked(sb, hash, iget_test, iget_set, &data);
 }
 /**
  * gfs2_set_iop - Sets inode operations
  * @inode: The inode with correct i_mode filled in
  *
  * GFS2 lookup code fills in vfs inode contents based on info obtained
  * from directory entry inside gfs2_inode_lookup().
  */
 static void gfs2_set_iop(struct inode *inode)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	umode_t mode = inode->i_mode;
 	if (S_ISREG(mode)) {
 		inode->i_op = &gfs2_file_iops;
 		if (gfs2_localflocks(sdp))
 			inode->i_fop = &gfs2_file_fops_nolock;
 		else
 			inode->i_fop = &gfs2_file_fops;
 	} else if (S_ISDIR(mode)) {
 		inode->i_op = &gfs2_dir_iops;
 		if (gfs2_localflocks(sdp))
 			inode->i_fop = &gfs2_dir_fops_nolock;
 		else
 			inode->i_fop = &gfs2_dir_fops;
 	} else if (S_ISLNK(mode)) {
 		inode->i_op = &gfs2_symlink_iops;
 	} else {
 		inode->i_op = &gfs2_file_iops;
 		init_special_inode(inode, inode->i_mode, inode->i_rdev);
 	}
 }
 /**
  * gfs2_inode_lookup - Lookup an inode
  * @sb: The super block
  * @no_addr: The inode number
  * @type: The type of the inode
  * non_block: Can we block on inodes that are being freed?
  *
  * Returns: A VFS inode, or an error
  */
 struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
 				u64 no_addr, u64 no_formal_ino, int non_block)
 {
 	struct inode *inode;
 	struct gfs2_inode *ip;
 	struct gfs2_glock *io_gl = NULL;
 	int error;
 	inode = gfs2_iget(sb, no_addr, non_block);
 	ip = GFS2_I(inode);
 	if (!inode)
 		return ERR_PTR(-ENOBUFS);
 	if (inode->i_state & I_NEW) {
 		struct gfs2_sbd *sdp = GFS2_SB(inode);
 		ip->i_no_formal_ino = no_formal_ino;
 		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
 		if (unlikely(error))
 			goto fail;
 		ip->i_gl->gl_object = ip;
 		error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
 		if (unlikely(error))
 			goto fail_put;
 		set_bit(GIF_INVALID, &ip->i_flags);
 		error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
 		if (unlikely(error))
 			goto fail_iopen;
 		ip->i_iopen_gh.gh_gl->gl_object = ip;
 		gfs2_glock_put(io_gl);
 		io_gl = NULL;
 		if (type == DT_UNKNOWN) {
 			/* Inode glock must be locked already */
 			error = gfs2_inode_refresh(GFS2_I(inode));
 			if (error)
 				goto fail_refresh;
 		} else {
 			inode->i_mode = DT2IF(type);
 		}
 		gfs2_set_iop(inode);
 		unlock_new_inode(inode);
 	}
 	return inode;
 fail_refresh:
 	ip->i_iopen_gh.gh_gl->gl_object = NULL;
 	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
 fail_iopen:
 	if (io_gl)
 		gfs2_glock_put(io_gl);
 fail_put:
 	ip->i_gl->gl_object = NULL;
 	gfs2_glock_put(ip->i_gl);
 fail:
 	iget_failed(inode);
 	return ERR_PTR(error);
 }
 struct inode *gfs2_lookup_by_inum(struct gfs2_sbd *sdp, u64 no_addr,
 				  u64 *no_formal_ino, unsigned int blktype)
 {
 	struct super_block *sb = sdp->sd_vfs;
 	struct gfs2_holder i_gh;
 	struct inode *inode = NULL;
 	int error;
 	/* Must not read in block until block type is verified */
 	error = gfs2_glock_nq_num(sdp, no_addr, &gfs2_inode_glops,
 				  LM_ST_EXCLUSIVE, GL_SKIP, &i_gh);
 	if (error)
 		return ERR_PTR(error);
 	error = gfs2_check_blk_type(sdp, no_addr, blktype);
 	if (error)
 		goto fail;
 	inode = gfs2_inode_lookup(sb, DT_UNKNOWN, no_addr, 0, 1);
 	if (IS_ERR(inode))
 		goto fail;
 	/* Two extra checks for NFS only */
 	if (no_formal_ino) {
 		error = -ESTALE;
 		if (GFS2_I(inode)->i_no_formal_ino != *no_formal_ino)
 			goto fail_iput;
 		error = -EIO;
 		if (GFS2_I(inode)->i_diskflags & GFS2_DIF_SYSTEM)
 			goto fail_iput;
 		error = 0;
 	}
 fail:
 	gfs2_glock_dq_uninit(&i_gh);
 	return error ? ERR_PTR(error) : inode;
 fail_iput:
 	iput(inode);
 	goto fail;
 }
 struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
 {
 	struct qstr qstr;
 	struct inode *inode;
 	gfs2_str2qstr(&qstr, name);
 	inode = gfs2_lookupi(dip, &qstr, 1);
 	/* gfs2_lookupi has inconsistent callers: vfs
 	 * related routines expect NULL for no entry found,
 	 * gfs2_lookup_simple callers expect ENOENT
 	 * and do not check for NULL.
 	 */
 	if (inode == NULL)
 		return ERR_PTR(-ENOENT);
 	else
 		return inode;
 }
 /**
  * gfs2_lookupi - Look up a filename in a directory and return its inode
  * @d_gh: An initialized holder for the directory glock
  * @name: The name of the inode to look for
  * @is_root: If 1, ignore the caller's permissions
  * @i_gh: An uninitialized holder for the new inode glock
  *
  * This can be called via the VFS filldir function when NFS is doing
  * a readdirplus and the inode which its intending to stat isn't
  * already in cache. In this case we must not take the directory glock
  * again, since the readdir call will have already taken that lock.
  *
  * Returns: errno
  */
 struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
 			   int is_root)
 {
 	struct super_block *sb = dir->i_sb;
 	struct gfs2_inode *dip = GFS2_I(dir);
 	struct gfs2_holder d_gh;
 	int error = 0;
 	struct inode *inode = NULL;
 	int unlock = 0;
 	if (!name->len || name->len > GFS2_FNAMESIZE)
 		return ERR_PTR(-ENAMETOOLONG);
 	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
 	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
 	     dir == sb->s_root->d_inode)) {
 		igrab(dir);
 		return dir;
 	}
 	if (gfs2_glock_is_locked_by_me(dip->i_gl) == NULL) {
 		error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 		if (error)
 			return ERR_PTR(error);
 		unlock = 1;
 	}
 	if (!is_root) {
 		error = gfs2_permission(dir, MAY_EXEC);
 		if (error)
 			goto out;
 	}
 	inode = gfs2_dir_search(dir, name);
 	if (IS_ERR(inode))
 		error = PTR_ERR(inode);
 out:
 	if (unlock)
 		gfs2_glock_dq_uninit(&d_gh);
 	if (error == -ENOENT)
 		return NULL;
 	return inode ? inode : ERR_PTR(error);
 }
 /**
  * create_ok - OK to create a new on-disk inode here?
  * @dip:  Directory in which dinode is to be created
  * @name:  Name of new dinode
  * @mode:
  *
  * Returns: errno
  */
 static int create_ok(struct gfs2_inode *dip, const struct qstr *name,
 		     umode_t mode)
 {
 	int error;
 	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
 	if (error)
 		return error;
 	/*  Don't create entries in an unlinked directory  */
 	if (!dip->i_inode.i_nlink)
 		return -ENOENT;
 	error = gfs2_dir_check(&dip->i_inode, name, NULL);
 	switch (error) {
 	case -ENOENT:
 		error = 0;
 		break;
 	case 0:
 		return -EEXIST;
 	default:
 		return error;
 	}
 	if (dip->i_entries == (u32)-1)
 		return -EFBIG;
 	if (S_ISDIR(mode) && dip->i_inode.i_nlink == (u32)-1)
 		return -EMLINK;
 	return 0;
 }
 static void munge_mode_uid_gid(const struct gfs2_inode *dip,
 			       struct inode *inode)
 {
 	if (GFS2_SB(&dip->i_inode)->sd_args.ar_suiddir &&
 	    (dip->i_inode.i_mode & S_ISUID) && dip->i_inode.i_uid) {
 		if (S_ISDIR(inode->i_mode))
 			inode->i_mode |= S_ISUID;
 		else if (dip->i_inode.i_uid != current_fsuid())
 			inode->i_mode &= ~07111;
 		inode->i_uid = dip->i_inode.i_uid;
 	} else
 		inode->i_uid = current_fsuid();
 	if (dip->i_inode.i_mode & S_ISGID) {
 		if (S_ISDIR(inode->i_mode))
 			inode->i_mode |= S_ISGID;
 		inode->i_gid = dip->i_inode.i_gid;
 	} else
 		inode->i_gid = current_fsgid();
 }
-static int alloc_dinode(struct gfs2_inode *ip)
+static int alloc_dinode(struct gfs2_inode *ip, u32 flags)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	int error;
 	int dblocks = 1;
-	error = gfs2_inplace_reserve(ip, RES_DINODE);
+	error = gfs2_inplace_reserve(ip, RES_DINODE, flags);
 	if (error)
 		goto out;
 	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS, 0);
 	if (error)
 		goto out_ipreserv;
 	error = gfs2_alloc_blocks(ip, &ip->i_no_addr, &dblocks, 1, &ip->i_generation);
 	ip->i_no_formal_ino = ip->i_generation;
 	ip->i_inode.i_ino = ip->i_no_addr;
 	ip->i_goal = ip->i_no_addr;
 	gfs2_trans_end(sdp);
 out_ipreserv:
 	gfs2_inplace_release(ip);
 out:
 	return error;
 }
 static void gfs2_init_dir(struct buffer_head *dibh,
 			  const struct gfs2_inode *parent)
 {
 	struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
 	struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
 	gfs2_qstr2dirent(&gfs2_qdot, GFS2_DIRENT_SIZE(gfs2_qdot.len), dent);
 	dent->de_inum = di->di_num; /* already GFS2 endian */
 	dent->de_type = cpu_to_be16(DT_DIR);
 	dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
 	gfs2_qstr2dirent(&gfs2_qdotdot, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
 	gfs2_inum_out(parent, dent);
 	dent->de_type = cpu_to_be16(DT_DIR);
 }
 /**
  * init_dinode - Fill in a new dinode structure
  * @dip: The directory this inode is being created in
  * @ip: The inode
  * @symname: The symlink destination (if a symlink)
  * @bhp: The buffer head (returned to caller)
  *
  */
 static void init_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
 			const char *symname, struct buffer_head **bhp)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 	struct gfs2_dinode *di;
 	struct buffer_head *dibh;
 	struct timespec tv = CURRENT_TIME;
 	dibh = gfs2_meta_new(ip->i_gl, ip->i_no_addr);
 	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 	gfs2_metatype_set(dibh, GFS2_METATYPE_DI, GFS2_FORMAT_DI);
 	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
 	di = (struct gfs2_dinode *)dibh->b_data;
 	di->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino);
 	di->di_num.no_addr = cpu_to_be64(ip->i_no_addr);
 	di->di_mode = cpu_to_be32(ip->i_inode.i_mode);
 	di->di_uid = cpu_to_be32(ip->i_inode.i_uid);
 	di->di_gid = cpu_to_be32(ip->i_inode.i_gid);
 	di->di_nlink = 0;
 	di->di_size = cpu_to_be64(ip->i_inode.i_size);
 	di->di_blocks = cpu_to_be64(1);
 	di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(tv.tv_sec);
 	di->di_major = cpu_to_be32(MAJOR(ip->i_inode.i_rdev));
 	di->di_minor = cpu_to_be32(MINOR(ip->i_inode.i_rdev));
 	di->di_goal_meta = di->di_goal_data = cpu_to_be64(ip->i_no_addr);
 	di->di_generation = cpu_to_be64(ip->i_generation);
 	di->di_flags = 0;
 	di->__pad1 = 0;
 	di->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) ? GFS2_FORMAT_DE : 0);
 	di->di_height = 0;
 	di->__pad2 = 0;
 	di->__pad3 = 0;
 	di->di_depth = 0;
 	di->di_entries = 0;
 	memset(&di->__pad4, 0, sizeof(di->__pad4));
 	di->di_eattr = 0;
 	di->di_atime_nsec = cpu_to_be32(tv.tv_nsec);
 	di->di_mtime_nsec = cpu_to_be32(tv.tv_nsec);
 	di->di_ctime_nsec = cpu_to_be32(tv.tv_nsec);
 	memset(&di->di_reserved, 0, sizeof(di->di_reserved));
 	switch(ip->i_inode.i_mode & S_IFMT) {
 	case S_IFREG:
 		if ((dip->i_diskflags & GFS2_DIF_INHERIT_JDATA) ||
 		    gfs2_tune_get(sdp, gt_new_files_jdata))
 			di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
 		break;
 	case S_IFDIR:
 		di->di_flags |= cpu_to_be32(dip->i_diskflags &
 					    GFS2_DIF_INHERIT_JDATA);
 		di->di_flags |= cpu_to_be32(GFS2_DIF_JDATA);
 		di->di_size = cpu_to_be64(sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode));
 		di->di_entries = cpu_to_be32(2);
 		gfs2_init_dir(dibh, dip);
 		break;
 	case S_IFLNK:
 		memcpy(dibh->b_data + sizeof(struct gfs2_dinode), symname, ip->i_inode.i_size);
 		break;
 	}
 	set_buffer_uptodate(dibh);
 	*bhp = dibh;
 }
 static int make_dinode(struct gfs2_inode *dip, struct gfs2_inode *ip,
 		       const char *symname, struct buffer_head **bhp)
 {
 	struct inode *inode = &ip->i_inode;
 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 	int error;
 	error = gfs2_rindex_update(sdp);
 	if (error)
 		return error;
 	error = gfs2_quota_lock(dip, inode->i_uid, inode->i_gid);
 	if (error)
 		return error;
 	error = gfs2_quota_check(dip, inode->i_uid, inode->i_gid);
 	if (error)
 		goto out_quota;
 	error = gfs2_trans_begin(sdp, RES_DINODE + RES_QUOTA, 0);
 	if (error)
 		goto out_quota;
 	init_dinode(dip, ip, symname, bhp);
 	gfs2_quota_change(dip, +1, inode->i_uid, inode->i_gid);
 	gfs2_trans_end(sdp);
 out_quota:
 	gfs2_quota_unlock(dip);
 	return error;
 }
 static int link_dinode(struct gfs2_inode *dip, const struct qstr *name,
 		       struct gfs2_inode *ip)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 	int alloc_required;
 	struct buffer_head *dibh;
 	int error;
 	error = gfs2_rindex_update(sdp);
 	if (error)
 		return error;
 	error = gfs2_quota_lock(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
 	if (error)
 		goto fail;
 	error = alloc_required = gfs2_diradd_alloc_required(&dip->i_inode, name);
 	if (alloc_required < 0)
 		goto fail_quota_locks;
 	if (alloc_required) {
 		error = gfs2_quota_check(dip, dip->i_inode.i_uid, dip->i_inode.i_gid);
 		if (error)
 			goto fail_quota_locks;
-		error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres);
+		error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres, 0);
 		if (error)
 			goto fail_quota_locks;
 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 					 dip->i_rgd->rd_length +
 					 2 * RES_DINODE +
 					 RES_STATFS + RES_QUOTA, 0);
 		if (error)
 			goto fail_ipreserv;
 	} else {
 		error = gfs2_trans_begin(sdp, RES_LEAF + 2 * RES_DINODE, 0);
 		if (error)
 			goto fail_quota_locks;
 	}
 	error = gfs2_dir_add(&dip->i_inode, name, ip);
 	if (error)
 		goto fail_end_trans;
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error)
 		goto fail_end_trans;
 	set_nlink(&ip->i_inode, S_ISDIR(ip->i_inode.i_mode) ? 2 : 1);
 	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 	gfs2_dinode_out(ip, dibh->b_data);
 	brelse(dibh);
 	return 0;
 fail_end_trans:
 	gfs2_trans_end(sdp);
 fail_ipreserv:
 	if (alloc_required)
 		gfs2_inplace_release(dip);
 fail_quota_locks:
 	gfs2_quota_unlock(dip);
 fail:
 	return error;
 }
 static int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
 		    void *fs_info)
 {
 	const struct xattr *xattr;
 	int err = 0;
 	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
 		err = __gfs2_xattr_set(inode, xattr->name, xattr->value,
 				       xattr->value_len, 0,
 				       GFS2_EATYPE_SECURITY);
 		if (err < 0)
 			break;
 	}
 	return err;
 }
 static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
 			      const struct qstr *qstr)
 {
 	return security_inode_init_security(&ip->i_inode, &dip->i_inode, qstr,
 					    &gfs2_initxattrs, NULL);
 }
 /**
  * gfs2_create_inode - Create a new inode
  * @dir: The parent directory
  * @dentry: The new dentry
  * @mode: The permissions on the new inode
  * @dev: For device nodes, this is the device number
  * @symname: For symlinks, this is the link destination
  * @size: The initial size of the inode (ignored for directories)
  *
  * Returns: 0 on success, or error code
  */
 static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
 			     umode_t mode, dev_t dev, const char *symname,
 			     unsigned int size, int excl)
 {
 	const struct qstr *name = &dentry->d_name;
 	struct gfs2_holder ghs[2];
 	struct inode *inode = NULL;
 	struct gfs2_inode *dip = GFS2_I(dir), *ip;
 	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
 	struct gfs2_glock *io_gl;
 	int error;
 	struct buffer_head *bh = NULL;
+	u32 aflags = 0;
 	if (!name->len || name->len > GFS2_FNAMESIZE)
 		return -ENAMETOOLONG;
 	error = gfs2_rs_alloc(dip);
 	if (error)
 		return error;
 	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 	if (error)
 		goto fail;
 	error = create_ok(dip, name, mode);
 	if ((error == -EEXIST) && S_ISREG(mode) && !excl) {
 		inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 		gfs2_glock_dq_uninit(ghs);
 		d_instantiate(dentry, inode);
 		return IS_ERR(inode) ? PTR_ERR(inode) : 0;
 	}
 	if (error)
 		goto fail_gunlock;
 	inode = new_inode(sdp->sd_vfs);
 	ip = GFS2_I(inode);
 	error = gfs2_rs_alloc(ip);
 	if (error)
 		goto fail_free_inode;
 	set_bit(GIF_INVALID, &ip->i_flags);
 	inode->i_mode = mode;
 	inode->i_rdev = dev;
 	inode->i_size = size;
 	munge_mode_uid_gid(dip, inode);
 	ip->i_goal = dip->i_goal;
-	error = alloc_dinode(ip);
+	if ((GFS2_I(sdp->sd_root_dir->d_inode) == dip) ||
+	    (dip->i_diskflags & GFS2_DIF_TOPDIR))
+		aflags |= GFS2_AF_ORLOV;
+	error = alloc_dinode(ip, aflags);
 	if (error)
 		goto fail_free_inode;
 	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
 	if (error)
 		goto fail_free_inode;
 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
 	if (error)
 		goto fail_free_inode;
 	error = make_dinode(dip, ip, symname, &bh);
 	if (error)
 		goto fail_gunlock2;
 	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
 	if (error)
 		goto fail_gunlock2;
 	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
 	if (error)
 		goto fail_gunlock2;
 	ip->i_iopen_gh.gh_gl->gl_object = ip;
 	gfs2_glock_put(io_gl);
 	gfs2_set_iop(inode);
 	insert_inode_hash(inode);
 	error = gfs2_inode_refresh(ip);
 	if (error)
 		goto fail_gunlock3;
 	error = gfs2_acl_create(dip, inode);
 	if (error)
 		goto fail_gunlock3;
 	error = gfs2_security_init(dip, ip, name);
 	if (error)
 		goto fail_gunlock3;
 	error = link_dinode(dip, name, ip);
 	if (error)
 		goto fail_gunlock3;
 	if (bh)
 		brelse(bh);
 	gfs2_trans_end(sdp);
 	gfs2_inplace_release(dip);
 	gfs2_quota_unlock(dip);
 	mark_inode_dirty(inode);
 	gfs2_glock_dq_uninit_m(2, ghs);
 	d_instantiate(dentry, inode);
 	return 0;
 fail_gunlock3:
 	gfs2_glock_dq_uninit(ghs + 1);
 	if (ip->i_gl)
 		gfs2_glock_put(ip->i_gl);
 	goto fail_gunlock;
 fail_gunlock2:
 	gfs2_glock_dq_uninit(ghs + 1);
 fail_free_inode:
 	if (ip->i_gl)
 		gfs2_glock_put(ip->i_gl);
 	gfs2_rs_delete(ip);
 	free_inode_nonrcu(inode);
 	inode = NULL;
 fail_gunlock:
 	gfs2_glock_dq_uninit(ghs);
 	if (inode && !IS_ERR(inode)) {
 		set_bit(GIF_ALLOC_FAILED, &GFS2_I(inode)->i_flags);
 		iput(inode);
 	}
 fail:
 	if (bh)
 		brelse(bh);
 	return error;
 }
 /**
  * gfs2_create - Create a file
  * @dir: The directory in which to create the file
  * @dentry: The dentry of the new file
  * @mode: The mode of the new file
  *
  * Returns: errno
  */
 static int gfs2_create(struct inode *dir, struct dentry *dentry,
 		       umode_t mode, bool excl)
 {
 	return gfs2_create_inode(dir, dentry, S_IFREG | mode, 0, NULL, 0, excl);
 }
 /**
  * gfs2_lookup - Look up a filename in a directory and return its inode
  * @dir: The directory inode
  * @dentry: The dentry of the new inode
  * @nd: passed from Linux VFS, ignored by us
  *
  * Called by the VFS layer. Lock dir and call gfs2_lookupi()
  *
  * Returns: errno
  */
 static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
 				  unsigned int flags)
 {
 	struct inode *inode = gfs2_lookupi(dir, &dentry->d_name, 0);
 	if (inode && !IS_ERR(inode)) {
 		struct gfs2_glock *gl = GFS2_I(inode)->i_gl;
 		struct gfs2_holder gh;
 		int error;
 		error = gfs2_glock_nq_init(gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 		if (error) {
 			iput(inode);
 			return ERR_PTR(error);
 		}
 		gfs2_glock_dq_uninit(&gh);
 	}
 	return d_splice_alias(inode, dentry);
 }
 /**
  * gfs2_link - Link to a file
  * @old_dentry: The inode to link
  * @dir: Add link to this directory
  * @dentry: The name of the link
  *
  * Link the inode in "old_dentry" into the directory "dir" with the
  * name in "dentry".
  *
  * Returns: errno
  */
 static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 		     struct dentry *dentry)
 {
 	struct gfs2_inode *dip = GFS2_I(dir);
 	struct gfs2_sbd *sdp = GFS2_SB(dir);
 	struct inode *inode = old_dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder ghs[2];
 	struct buffer_head *dibh;
 	int alloc_required;
 	int error;
 	if (S_ISDIR(inode->i_mode))
 		return -EPERM;
 	error = gfs2_rs_alloc(dip);
 	if (error)
 		return error;
 	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + 1);
 	error = gfs2_glock_nq(ghs); /* parent */
 	if (error)
 		goto out_parent;
 	error = gfs2_glock_nq(ghs + 1); /* child */
 	if (error)
 		goto out_child;
 	error = -ENOENT;
 	if (inode->i_nlink == 0)
 		goto out_gunlock;
 	error = gfs2_permission(dir, MAY_WRITE | MAY_EXEC);
 	if (error)
 		goto out_gunlock;
 	error = gfs2_dir_check(dir, &dentry->d_name, NULL);
 	switch (error) {
 	case -ENOENT:
 		break;
 	case 0:
 		error = -EEXIST;
 	default:
 		goto out_gunlock;
 	}
 	error = -EINVAL;
 	if (!dip->i_inode.i_nlink)
 		goto out_gunlock;
 	error = -EFBIG;
 	if (dip->i_entries == (u32)-1)
 		goto out_gunlock;
 	error = -EPERM;
 	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 		goto out_gunlock;
 	error = -EINVAL;
 	if (!ip->i_inode.i_nlink)
 		goto out_gunlock;
 	error = -EMLINK;
 	if (ip->i_inode.i_nlink == (u32)-1)
 		goto out_gunlock;
 	alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);
 	if (error < 0)
 		goto out_gunlock;
 	error = 0;
 	if (alloc_required) {
 		error = gfs2_quota_lock_check(dip);
 		if (error)
 			goto out_gunlock;
-		error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres);
+		error = gfs2_inplace_reserve(dip, sdp->sd_max_dirres, 0);
 		if (error)
 			goto out_gunlock_q;
 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 					 gfs2_rg_blocks(dip, sdp->sd_max_dirres) +
 					 2 * RES_DINODE + RES_STATFS +
 					 RES_QUOTA, 0);
 		if (error)
 			goto out_ipres;
 	} else {
 		error = gfs2_trans_begin(sdp, 2 * RES_DINODE + RES_LEAF, 0);
 		if (error)
 			goto out_ipres;
 	}
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error)
 		goto out_end_trans;
 	error = gfs2_dir_add(dir, &dentry->d_name, ip);
 	if (error)
 		goto out_brelse;
 	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 	inc_nlink(&ip->i_inode);
 	ip->i_inode.i_ctime = CURRENT_TIME;
 	ihold(inode);
 	d_instantiate(dentry, inode);
 	mark_inode_dirty(inode);
 out_brelse:
 	brelse(dibh);
 out_end_trans:
 	gfs2_trans_end(sdp);
 out_ipres:
 	if (alloc_required)
 		gfs2_inplace_release(dip);
 out_gunlock_q:
 	if (alloc_required)
 		gfs2_quota_unlock(dip);
 out_gunlock:
 	gfs2_glock_dq(ghs + 1);
 out_child:
 	gfs2_glock_dq(ghs);
 out_parent:
 	gfs2_holder_uninit(ghs);
 	gfs2_holder_uninit(ghs + 1);
 	return error;
 }
 /*
  * gfs2_unlink_ok - check to see that a inode is still in a directory
  * @dip: the directory
  * @name: the name of the file
  * @ip: the inode
  *
  * Assumes that the lock on (at least) @dip is held.
  *
  * Returns: 0 if the parent/child relationship is correct, errno if it isn't
  */
 static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
 			  const struct gfs2_inode *ip)
 {
 	int error;
 	if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
 		return -EPERM;
 	if ((dip->i_inode.i_mode & S_ISVTX) &&
 	    dip->i_inode.i_uid != current_fsuid() &&
 	    ip->i_inode.i_uid != current_fsuid() && !capable(CAP_FOWNER))
 		return -EPERM;
 	if (IS_APPEND(&dip->i_inode))
 		return -EPERM;
 	error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
 	if (error)
 		return error;
 	error = gfs2_dir_check(&dip->i_inode, name, ip);
 	if (error)
 		return error;
 	return 0;
 }
 /**
  * gfs2_unlink_inode - Removes an inode from its parent dir and unlinks it
  * @dip: The parent directory
  * @name: The name of the entry in the parent directory
  * @bh: The inode buffer for the inode to be removed
  * @inode: The inode to be removed
  *
  * Called with all the locks and in a transaction. This will only be
  * called for a directory after it has been checked to ensure it is empty.
  *
  * Returns: 0 on success, or an error
  */
 static int gfs2_unlink_inode(struct gfs2_inode *dip,
 			     const struct dentry *dentry,
 			     struct buffer_head *bh)
 {
 	struct inode *inode = dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	int error;
 	error = gfs2_dir_del(dip, dentry);
 	if (error)
 		return error;
 	ip->i_entries = 0;
 	inode->i_ctime = CURRENT_TIME;
 	if (S_ISDIR(inode->i_mode))
 		clear_nlink(inode);
 	else
 		drop_nlink(inode);
 	mark_inode_dirty(inode);
 	if (inode->i_nlink == 0)
 		gfs2_unlink_di(inode);
 	return 0;
 }
 /**
  * gfs2_unlink - Unlink an inode (this does rmdir as well)
  * @dir: The inode of the directory containing the inode to unlink
  * @dentry: The file itself
  *
  * This routine uses the type of the inode as a flag to figure out
  * whether this is an unlink or an rmdir.
  *
  * Returns: errno
  */
 static int gfs2_unlink(struct inode *dir, struct dentry *dentry)
 {
 	struct gfs2_inode *dip = GFS2_I(dir);
 	struct gfs2_sbd *sdp = GFS2_SB(dir);
 	struct inode *inode = dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct buffer_head *bh;
 	struct gfs2_holder ghs[3];
 	struct gfs2_rgrpd *rgd;
 	int error;
 	error = gfs2_rindex_update(sdp);
 	if (error)
 		return error;
 	error = -EROFS;
 	gfs2_holder_init(dip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 	gfs2_holder_init(ip->i_gl,  LM_ST_EXCLUSIVE, 0, ghs + 1);
 	rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1);
 	if (!rgd)
 		goto out_inodes;
 	gfs2_holder_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + 2);
 	error = gfs2_glock_nq(ghs); /* parent */
 	if (error)
 		goto out_parent;
 	error = gfs2_glock_nq(ghs + 1); /* child */
 	if (error)
 		goto out_child;
 	error = -ENOENT;
 	if (inode->i_nlink == 0)
 		goto out_rgrp;
 	if (S_ISDIR(inode->i_mode)) {
 		error = -ENOTEMPTY;
 		if (ip->i_entries > 2 || inode->i_nlink > 2)
 			goto out_rgrp;
 	}
 	error = gfs2_glock_nq(ghs + 2); /* rgrp */
 	if (error)
 		goto out_rgrp;
 	error = gfs2_unlink_ok(dip, &dentry->d_name, ip);
 	if (error)
 		goto out_gunlock;
 	error = gfs2_trans_begin(sdp, 2*RES_DINODE + 3*RES_LEAF + RES_RG_BIT, 0);
 	if (error)
 		goto out_gunlock;
 	error = gfs2_meta_inode_buffer(ip, &bh);
 	if (error)
 		goto out_end_trans;
 	error = gfs2_unlink_inode(dip, dentry, bh);
 	brelse(bh);
 out_end_trans:
 	gfs2_trans_end(sdp);
 out_gunlock:
 	gfs2_glock_dq(ghs + 2);
 out_rgrp:
 	gfs2_glock_dq(ghs + 1);
 out_child:
 	gfs2_glock_dq(ghs);
 out_parent:
 	gfs2_holder_uninit(ghs + 2);
 out_inodes:
 	gfs2_holder_uninit(ghs + 1);
 	gfs2_holder_uninit(ghs);
 	return error;
 }
 /**
  * gfs2_symlink - Create a symlink
  * @dir: The directory to create the symlink in
  * @dentry: The dentry to put the symlink in
  * @symname: The thing which the link points to
  *
  * Returns: errno
  */
 static int gfs2_symlink(struct inode *dir, struct dentry *dentry,
 			const char *symname)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(dir);
 	unsigned int size;
 	size = strlen(symname);
 	if (size > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode) - 1)
 		return -ENAMETOOLONG;
 	return gfs2_create_inode(dir, dentry, S_IFLNK | S_IRWXUGO, 0, symname, size, 0);
 }
 /**
  * gfs2_mkdir - Make a directory
  * @dir: The parent directory of the new one
  * @dentry: The dentry of the new directory
  * @mode: The mode of the new directory
  *
  * Returns: errno
  */
 static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
 	return gfs2_create_inode(dir, dentry, S_IFDIR | mode, 0, NULL, 0, 0);
 }
 /**
  * gfs2_mknod - Make a special file
  * @dir: The directory in which the special file will reside
  * @dentry: The dentry of the special file
  * @mode: The mode of the special file
  * @dev: The device specification of the special file
  *
  */
 static int gfs2_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
 		      dev_t dev)
 {
 	return gfs2_create_inode(dir, dentry, mode, dev, NULL, 0, 0);
 }
 /*
  * gfs2_ok_to_move - check if it's ok to move a directory to another directory
  * @this: move this
  * @to: to here
  *
  * Follow @to back to the root and make sure we don't encounter @this
  * Assumes we already hold the rename lock.
  *
  * Returns: errno
  */
 static int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
 {
 	struct inode *dir = &to->i_inode;
 	struct super_block *sb = dir->i_sb;
 	struct inode *tmp;
 	int error = 0;
 	igrab(dir);
 	for (;;) {
 		if (dir == &this->i_inode) {
 			error = -EINVAL;
 			break;
 		}
 		if (dir == sb->s_root->d_inode) {
 			error = 0;
 			break;
 		}
 		tmp = gfs2_lookupi(dir, &gfs2_qdotdot, 1);
 		if (IS_ERR(tmp)) {
 			error = PTR_ERR(tmp);
 			break;
 		}
 		iput(dir);
 		dir = tmp;
 	}
 	iput(dir);
 	return error;
 }
 /**
  * gfs2_rename - Rename a file
  * @odir: Parent directory of old file name
  * @odentry: The old dentry of the file
  * @ndir: Parent directory of new file name
  * @ndentry: The new dentry of the file
  *
  * Returns: errno
  */
 static int gfs2_rename(struct inode *odir, struct dentry *odentry,
 		       struct inode *ndir, struct dentry *ndentry)
 {
 	struct gfs2_inode *odip = GFS2_I(odir);
 	struct gfs2_inode *ndip = GFS2_I(ndir);
 	struct gfs2_inode *ip = GFS2_I(odentry->d_inode);
 	struct gfs2_inode *nip = NULL;
 	struct gfs2_sbd *sdp = GFS2_SB(odir);
 	struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, };
 	struct gfs2_rgrpd *nrgd;
 	unsigned int num_gh;
 	int dir_rename = 0;
 	int alloc_required = 0;
 	unsigned int x;
 	int error;
 	if (ndentry->d_inode) {
 		nip = GFS2_I(ndentry->d_inode);
 		if (ip == nip)
 			return 0;
 	}
 	error = gfs2_rindex_update(sdp);
 	if (error)
 		return error;
 	error = gfs2_rs_alloc(ndip);
 	if (error)
 		return error;
 	if (odip != ndip) {
 		error = gfs2_glock_nq_init(sdp->sd_rename_gl, LM_ST_EXCLUSIVE,
 					   0, &r_gh);
 		if (error)
 			goto out;
 		if (S_ISDIR(ip->i_inode.i_mode)) {
 			dir_rename = 1;
 			/* don't move a dirctory into it's subdir */
 			error = gfs2_ok_to_move(ip, ndip);
 			if (error)
 				goto out_gunlock_r;
 		}
 	}
 	num_gh = 1;
 	gfs2_holder_init(odip->i_gl, LM_ST_EXCLUSIVE, 0, ghs);
 	if (odip != ndip) {
 		gfs2_holder_init(ndip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 		num_gh++;
 	}
 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 	num_gh++;
 	if (nip) {
 		gfs2_holder_init(nip->i_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh);
 		num_gh++;
 		/* grab the resource lock for unlink flag twiddling
 		 * this is the case of the target file already existing
 		 * so we unlink before doing the rename
 		 */
 		nrgd = gfs2_blk2rgrpd(sdp, nip->i_no_addr, 1);
 		if (nrgd)
 			gfs2_holder_init(nrgd->rd_gl, LM_ST_EXCLUSIVE, 0, ghs + num_gh++);
 	}
 	for (x = 0; x < num_gh; x++) {
 		error = gfs2_glock_nq(ghs + x);
 		if (error)
 			goto out_gunlock;
 	}
 	error = -ENOENT;
 	if (ip->i_inode.i_nlink == 0)
 		goto out_gunlock;
 	/* Check out the old directory */
 	error = gfs2_unlink_ok(odip, &odentry->d_name, ip);
 	if (error)
 		goto out_gunlock;
 	/* Check out the new directory */
 	if (nip) {
 		error = gfs2_unlink_ok(ndip, &ndentry->d_name, nip);
 		if (error)
 			goto out_gunlock;
 		if (nip->i_inode.i_nlink == 0) {
 			error = -EAGAIN;
 			goto out_gunlock;
 		}
 		if (S_ISDIR(nip->i_inode.i_mode)) {
 			if (nip->i_entries < 2) {
 				gfs2_consist_inode(nip);
 				error = -EIO;
 				goto out_gunlock;
 			}
 			if (nip->i_entries > 2) {
 				error = -ENOTEMPTY;
 				goto out_gunlock;
 			}
 		}
 	} else {
 		error = gfs2_permission(ndir, MAY_WRITE | MAY_EXEC);
 		if (error)
 			goto out_gunlock;
 		error = gfs2_dir_check(ndir, &ndentry->d_name, NULL);
 		switch (error) {
 		case -ENOENT:
 			error = 0;
 			break;
 		case 0:
 			error = -EEXIST;
 		default:
 			goto out_gunlock;
 		};
 		if (odip != ndip) {
 			if (!ndip->i_inode.i_nlink) {
 				error = -ENOENT;
 				goto out_gunlock;
 			}
 			if (ndip->i_entries == (u32)-1) {
 				error = -EFBIG;
 				goto out_gunlock;
 			}
 			if (S_ISDIR(ip->i_inode.i_mode) &&
 			    ndip->i_inode.i_nlink == (u32)-1) {
 				error = -EMLINK;
 				goto out_gunlock;
 			}
 		}
 	}
 	/* Check out the dir to be renamed */
 	if (dir_rename) {
 		error = gfs2_permission(odentry->d_inode, MAY_WRITE);
 		if (error)
 			goto out_gunlock;
 	}
 	if (nip == NULL)
 		alloc_required = gfs2_diradd_alloc_required(ndir, &ndentry->d_name);
 	error = alloc_required;
 	if (error < 0)
 		goto out_gunlock;
 	if (alloc_required) {
 		error = gfs2_quota_lock_check(ndip);
 		if (error)
 			goto out_gunlock;
-		error = gfs2_inplace_reserve(ndip, sdp->sd_max_dirres);
+		error = gfs2_inplace_reserve(ndip, sdp->sd_max_dirres, 0);
 		if (error)
 			goto out_gunlock_q;
 		error = gfs2_trans_begin(sdp, sdp->sd_max_dirres +
 					 gfs2_rg_blocks(ndip, sdp->sd_max_dirres) +
 					 4 * RES_DINODE + 4 * RES_LEAF +
 					 RES_STATFS + RES_QUOTA + 4, 0);
 		if (error)
 			goto out_ipreserv;
 	} else {
 		error = gfs2_trans_begin(sdp, 4 * RES_DINODE +
 					 5 * RES_LEAF + 4, 0);
 		if (error)
 			goto out_gunlock;
 	}
 	/* Remove the target file, if it exists */
 	if (nip) {
 		struct buffer_head *bh;
 		error = gfs2_meta_inode_buffer(nip, &bh);
 		if (error)
 			goto out_end_trans;
 		error = gfs2_unlink_inode(ndip, ndentry, bh);
 		brelse(bh);
 	}
 	if (dir_rename) {
 		error = gfs2_dir_mvino(ip, &gfs2_qdotdot, ndip, DT_DIR);
 		if (error)
 			goto out_end_trans;
 	} else {
 		struct buffer_head *dibh;
 		error = gfs2_meta_inode_buffer(ip, &dibh);
 		if (error)
 			goto out_end_trans;
 		ip->i_inode.i_ctime = CURRENT_TIME;
 		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 		gfs2_dinode_out(ip, dibh->b_data);
 		brelse(dibh);
 	}
 	error = gfs2_dir_del(odip, odentry);
 	if (error)
 		goto out_end_trans;
 	error = gfs2_dir_add(ndir, &ndentry->d_name, ip);
 	if (error)
 		goto out_end_trans;
 out_end_trans:
 	gfs2_trans_end(sdp);
 out_ipreserv:
 	if (alloc_required)
 		gfs2_inplace_release(ndip);
 out_gunlock_q:
 	if (alloc_required)
 		gfs2_quota_unlock(ndip);
 out_gunlock:
 	while (x--) {
 		gfs2_glock_dq(ghs + x);
 		gfs2_holder_uninit(ghs + x);
 	}
 out_gunlock_r:
 	if (r_gh.gh_gl)
 		gfs2_glock_dq_uninit(&r_gh);
 out:
 	return error;
 }
 /**
  * gfs2_follow_link - Follow a symbolic link
  * @dentry: The dentry of the link
  * @nd: Data that we pass to vfs_follow_link()
  *
  * This can handle symlinks of any size.
  *
  * Returns: 0 on success or error code
  */
 static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
 	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
 	struct gfs2_holder i_gh;
 	struct buffer_head *dibh;
 	unsigned int size;
 	char *buf;
 	int error;
 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
 	error = gfs2_glock_nq(&i_gh);
 	if (error) {
 		gfs2_holder_uninit(&i_gh);
 		nd_set_link(nd, ERR_PTR(error));
 		return NULL;
 	}
 	size = (unsigned int)i_size_read(&ip->i_inode);
 	if (size == 0) {
 		gfs2_consist_inode(ip);
 		buf = ERR_PTR(-EIO);
 		goto out;
 	}
 	error = gfs2_meta_inode_buffer(ip, &dibh);
 	if (error) {
 		buf = ERR_PTR(error);
 		goto out;
 	}
 	buf = kzalloc(size + 1, GFP_NOFS);
 	if (!buf)
 		buf = ERR_PTR(-ENOMEM);
 	else
 		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
 	brelse(dibh);
 out:
 	gfs2_glock_dq_uninit(&i_gh);
 	nd_set_link(nd, buf);
 	return NULL;
 }
 static void gfs2_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
 {
 	char *s = nd_get_link(nd);
 	if (!IS_ERR(s))
 		kfree(s);
 }
 /**
  * gfs2_permission -
  * @inode: The inode
  * @mask: The mask to be tested
  * @flags: Indicates whether this is an RCU path walk or not
  *
  * This may be called from the VFS directly, or from within GFS2 with the
  * inode locked, so we look to see if the glock is already locked and only
  * lock the glock if its not already been done.
  *
  * Returns: errno
  */
 int gfs2_permission(struct inode *inode, int mask)
 {
 	struct gfs2_inode *ip;
 	struct gfs2_holder i_gh;
 	int error;
 	int unlock = 0;
 	ip = GFS2_I(inode);
 	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
 		if (mask & MAY_NOT_BLOCK)
 			return -ECHILD;
 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
 		if (error)
 			return error;
 		unlock = 1;
 	}
 	if ((mask & MAY_WRITE) && IS_IMMUTABLE(inode))
 		error = -EACCES;
 	else
 		error = generic_permission(inode, mask);
 	if (unlock)
 		gfs2_glock_dq_uninit(&i_gh);
 	return error;
 }
 static int __gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
 {
 	setattr_copy(inode, attr);
 	mark_inode_dirty(inode);
 	return 0;
 }
 /**
  * gfs2_setattr_simple -
  * @ip:
  * @attr:
  *
  * Returns: errno
  */
 int gfs2_setattr_simple(struct inode *inode, struct iattr *attr)
 {
 	int error;
 	if (current->journal_info)
 		return __gfs2_setattr_simple(inode, attr);
 	error = gfs2_trans_begin(GFS2_SB(inode), RES_DINODE, 0);
 	if (error)
 		return error;
 	error = __gfs2_setattr_simple(inode, attr);
 	gfs2_trans_end(GFS2_SB(inode));
 	return error;
 }
 static int setattr_chown(struct inode *inode, struct iattr *attr)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	u32 ouid, ogid, nuid, ngid;
 	int error;
 	ouid = inode->i_uid;
 	ogid = inode->i_gid;
 	nuid = attr->ia_uid;
 	ngid = attr->ia_gid;
 	if (!(attr->ia_valid & ATTR_UID) || ouid == nuid)
 		ouid = nuid = NO_QUOTA_CHANGE;
 	if (!(attr->ia_valid & ATTR_GID) || ogid == ngid)
 		ogid = ngid = NO_QUOTA_CHANGE;
 	error = gfs2_quota_lock(ip, nuid, ngid);
 	if (error)
 		return error;
 	if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
 		error = gfs2_quota_check(ip, nuid, ngid);
 		if (error)
 			goto out_gunlock_q;
 	}
 	error = gfs2_trans_begin(sdp, RES_DINODE + 2 * RES_QUOTA, 0);
 	if (error)
 		goto out_gunlock_q;
 	error = gfs2_setattr_simple(inode, attr);
 	if (error)
 		goto out_end_trans;
 	if (ouid != NO_QUOTA_CHANGE || ogid != NO_QUOTA_CHANGE) {
 		u64 blocks = gfs2_get_inode_blocks(&ip->i_inode);
 		gfs2_quota_change(ip, -blocks, ouid, ogid);
 		gfs2_quota_change(ip, blocks, nuid, ngid);
 	}
 out_end_trans:
 	gfs2_trans_end(sdp);
 out_gunlock_q:
 	gfs2_quota_unlock(ip);
 	return error;
 }
 /**
  * gfs2_setattr - Change attributes on an inode
  * @dentry: The dentry which is changing
  * @attr: The structure describing the change
  *
  * The VFS layer wants to change one or more of an inodes attributes.  Write
  * that change out to disk.
  *
  * Returns: errno
  */
 static int gfs2_setattr(struct dentry *dentry, struct iattr *attr)
 {
 	struct inode *inode = dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder i_gh;
 	int error;
 	error = gfs2_rs_alloc(ip);
 	if (error)
 		return error;
 	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
 	if (error)
 		return error;
 	error = -EPERM;
 	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
 		goto out;
 	error = inode_change_ok(inode, attr);
 	if (error)
 		goto out;
 	if (attr->ia_valid & ATTR_SIZE)
 		error = gfs2_setattr_size(inode, attr->ia_size);
 	else if (attr->ia_valid & (ATTR_UID | ATTR_GID))
 		error = setattr_chown(inode, attr);
 	else if ((attr->ia_valid & ATTR_MODE) && IS_POSIXACL(inode))
 		error = gfs2_acl_chmod(ip, attr);
 	else
 		error = gfs2_setattr_simple(inode, attr);
 out:
 	if (!error)
 		mark_inode_dirty(inode);
 	gfs2_glock_dq_uninit(&i_gh);
 	return error;
 }
 /**
  * gfs2_getattr - Read out an inode's attributes
  * @mnt: The vfsmount the inode is being accessed from
  * @dentry: The dentry to stat
  * @stat: The inode's stats
  *
  * This may be called from the VFS directly, or from within GFS2 with the
  * inode locked, so we look to see if the glock is already locked and only
  * lock the glock if its not already been done. Note that its the NFS
  * readdirplus operation which causes this to be called (from filldir)
  * with the glock already held.
  *
  * Returns: errno
  */
 static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
 			struct kstat *stat)
 {
 	struct inode *inode = dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder gh;
 	int error;
 	int unlock = 0;
 	if (gfs2_glock_is_locked_by_me(ip->i_gl) == NULL) {
 		error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 		if (error)
 			return error;
 		unlock = 1;
 	}
 	generic_fillattr(inode, stat);
 	if (unlock)
 		gfs2_glock_dq_uninit(&gh);
 	return 0;
 }
 static int gfs2_setxattr(struct dentry *dentry, const char *name,
 			 const void *data, size_t size, int flags)
 {
 	struct inode *inode = dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder gh;
 	int ret;
 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 	ret = gfs2_glock_nq(&gh);
 	if (ret == 0) {
 		ret = gfs2_rs_alloc(ip);
 		if (ret == 0)
 			ret = generic_setxattr(dentry, name, data, size, flags);
 		gfs2_glock_dq(&gh);
 	}
 	gfs2_holder_uninit(&gh);
 	return ret;
 }
 static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name,
 			     void *data, size_t size)
 {
 	struct inode *inode = dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder gh;
 	int ret;
 	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
 	ret = gfs2_glock_nq(&gh);
 	if (ret == 0) {
 		ret = generic_getxattr(dentry, name, data, size);
 		gfs2_glock_dq(&gh);
 	}
 	gfs2_holder_uninit(&gh);
 	return ret;
 }
 static int gfs2_removexattr(struct dentry *dentry, const char *name)
 {
 	struct inode *inode = dentry->d_inode;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder gh;
 	int ret;
 	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
 	ret = gfs2_glock_nq(&gh);
 	if (ret == 0) {
 		ret = gfs2_rs_alloc(ip);
 		if (ret == 0)
 			ret = generic_removexattr(dentry, name);
 		gfs2_glock_dq(&gh);
 	}
 	gfs2_holder_uninit(&gh);
 	return ret;
 }
 static int gfs2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 		       u64 start, u64 len)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_holder gh;
 	int ret;
 	ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC);
 	if (ret)
 		return ret;
 	mutex_lock(&inode->i_mutex);
 	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh);
 	if (ret)
 		goto out;
 	if (gfs2_is_stuffed(ip)) {
 		u64 phys = ip->i_no_addr << inode->i_blkbits;
 		u64 size = i_size_read(inode);
 		u32 flags = FIEMAP_EXTENT_LAST|FIEMAP_EXTENT_NOT_ALIGNED|
 			    FIEMAP_EXTENT_DATA_INLINE;
 		phys += sizeof(struct gfs2_dinode);
 		phys += start;
 		if (start + len > size)
 			len = size - start;
 		if (start < size)
 			ret = fiemap_fill_next_extent(fieinfo, start, phys,
 						      len, flags);
 		if (ret == 1)
 			ret = 0;
 	} else {
 		ret = __generic_block_fiemap(inode, fieinfo, start, len,
 					     gfs2_block_map);
 	}
 	gfs2_glock_dq_uninit(&gh);
 out:
 	mutex_unlock(&inode->i_mutex);
 	return ret;
 }
 const struct inode_operations gfs2_file_iops = {
 	.permission = gfs2_permission,
 	.setattr = gfs2_setattr,
 	.getattr = gfs2_getattr,
 	.setxattr = gfs2_setxattr,
 	.getxattr = gfs2_getxattr,
 	.listxattr = gfs2_listxattr,
 	.removexattr = gfs2_removexattr,
 	.fiemap = gfs2_fiemap,
 	.get_acl = gfs2_get_acl,
 };
 const struct inode_operations gfs2_dir_iops = {
 	.create = gfs2_create,
 	.lookup = gfs2_lookup,
 	.link = gfs2_link,
 	.unlink = gfs2_unlink,
 	.symlink = gfs2_symlink,
 	.mkdir = gfs2_mkdir,
 	.rmdir = gfs2_unlink,
 	.mknod = gfs2_mknod,
 	.rename = gfs2_rename,
 	.permission = gfs2_permission,
 	.setattr = gfs2_setattr,
 	.getattr = gfs2_getattr,
 	.setxattr = gfs2_setxattr,
 	.getxattr = gfs2_getxattr,
 	.listxattr = gfs2_listxattr,
 	.removexattr = gfs2_removexattr,
 	.fiemap = gfs2_fiemap,
 	.get_acl = gfs2_get_acl,
 };
 const struct inode_operations gfs2_symlink_iops = {
 	.readlink = generic_readlink,
 	.follow_link = gfs2_follow_link,
 	.put_link = gfs2_put_link,
 	.permission = gfs2_permission,
 	.setattr = gfs2_setattr,
 	.getattr = gfs2_getattr,
 	.setxattr = gfs2_setxattr,
 	.getxattr = gfs2_getxattr,
 	.listxattr = gfs2_listxattr,
 	.removexattr = gfs2_removexattr,
 	.fiemap = gfs2_fiemap,
 	.get_acl = gfs2_get_acl,
 };

fs/gfs2/quota.c

Diff comments View file @ 9dbe961

1	/*	1	/*
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.	3	* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
4	*	4	*
5	* This copyrighted material is made available to anyone wishing to use,	5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions	6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.	7	* of the GNU General Public License version 2.
8	*/	8	*/
9		9
10	/*	10	/*
11	* Quota change tags are associated with each transaction that allocates or	11	* Quota change tags are associated with each transaction that allocates or
12	* deallocates space. Those changes are accumulated locally to each node (in a	12	* deallocates space. Those changes are accumulated locally to each node (in a
13	* per-node file) and then are periodically synced to the quota file. This	13	* per-node file) and then are periodically synced to the quota file. This
14	* avoids the bottleneck of constantly touching the quota file, but introduces	14	* avoids the bottleneck of constantly touching the quota file, but introduces
15	* fuzziness in the current usage value of IDs that are being used on different	15	* fuzziness in the current usage value of IDs that are being used on different
16	* nodes in the cluster simultaneously. So, it is possible for a user on	16	* nodes in the cluster simultaneously. So, it is possible for a user on
17	* multiple nodes to overrun their quota, but that overrun is controlable.	17	* multiple nodes to overrun their quota, but that overrun is controlable.
18	* Since quota tags are part of transactions, there is no need for a quota check	18	* Since quota tags are part of transactions, there is no need for a quota check
19	* program to be run on node crashes or anything like that.	19	* program to be run on node crashes or anything like that.
20	*	20	*
21	* There are couple of knobs that let the administrator manage the quota	21	* There are couple of knobs that let the administrator manage the quota
22	* fuzziness. "quota_quantum" sets the maximum time a quota change can be	22	* fuzziness. "quota_quantum" sets the maximum time a quota change can be
23	* sitting on one node before being synced to the quota file. (The default is	23	* sitting on one node before being synced to the quota file. (The default is
24	* 60 seconds.) Another knob, "quota_scale" controls how quickly the frequency	24	* 60 seconds.) Another knob, "quota_scale" controls how quickly the frequency
25	* of quota file syncs increases as the user moves closer to their limit. The	25	* of quota file syncs increases as the user moves closer to their limit. The
26	* more frequent the syncs, the more accurate the quota enforcement, but that	26	* more frequent the syncs, the more accurate the quota enforcement, but that
27	* means that there is more contention between the nodes for the quota file.	27	* means that there is more contention between the nodes for the quota file.
28	* The default value is one. This sets the maximum theoretical quota overrun	28	* The default value is one. This sets the maximum theoretical quota overrun
29	* (with infinite node with infinite bandwidth) to twice the user's limit. (In	29	* (with infinite node with infinite bandwidth) to twice the user's limit. (In
30	* practice, the maximum overrun you see should be much less.) A "quota_scale"	30	* practice, the maximum overrun you see should be much less.) A "quota_scale"
31	* number greater than one makes quota syncs more frequent and reduces the	31	* number greater than one makes quota syncs more frequent and reduces the
32	* maximum overrun. Numbers less than one (but greater than zero) make quota	32	* maximum overrun. Numbers less than one (but greater than zero) make quota
33	* syncs less frequent.	33	* syncs less frequent.
34	*	34	*
35	* GFS quotas also use per-ID Lock Value Blocks (LVBs) to cache the contents of	35	* GFS quotas also use per-ID Lock Value Blocks (LVBs) to cache the contents of
36	* the quota file, so it is not being constantly read.	36	* the quota file, so it is not being constantly read.
37	*/	37	*/
38		38
39	#include <linux/sched.h>	39	#include <linux/sched.h>
40	#include <linux/slab.h>	40	#include <linux/slab.h>
41	#include <linux/mm.h>	41	#include <linux/mm.h>
42	#include <linux/spinlock.h>	42	#include <linux/spinlock.h>
43	#include <linux/completion.h>	43	#include <linux/completion.h>
44	#include <linux/buffer_head.h>	44	#include <linux/buffer_head.h>
45	#include <linux/sort.h>	45	#include <linux/sort.h>
46	#include <linux/fs.h>	46	#include <linux/fs.h>
47	#include <linux/bio.h>	47	#include <linux/bio.h>
48	#include <linux/gfs2_ondisk.h>	48	#include <linux/gfs2_ondisk.h>
49	#include <linux/kthread.h>	49	#include <linux/kthread.h>
50	#include <linux/freezer.h>	50	#include <linux/freezer.h>
51	#include <linux/quota.h>	51	#include <linux/quota.h>
52	#include <linux/dqblk_xfs.h>	52	#include <linux/dqblk_xfs.h>
53		53
54	#include "gfs2.h"	54	#include "gfs2.h"
55	#include "incore.h"	55	#include "incore.h"
56	#include "bmap.h"	56	#include "bmap.h"
57	#include "glock.h"	57	#include "glock.h"
58	#include "glops.h"	58	#include "glops.h"
59	#include "log.h"	59	#include "log.h"
60	#include "meta_io.h"	60	#include "meta_io.h"
61	#include "quota.h"	61	#include "quota.h"
62	#include "rgrp.h"	62	#include "rgrp.h"
63	#include "super.h"	63	#include "super.h"
64	#include "trans.h"	64	#include "trans.h"
65	#include "inode.h"	65	#include "inode.h"
66	#include "util.h"	66	#include "util.h"
67		67
68	#define QUOTA_USER 1	68	#define QUOTA_USER 1
69	#define QUOTA_GROUP 0	69	#define QUOTA_GROUP 0
70		70
71	struct gfs2_quota_change_host {	71	struct gfs2_quota_change_host {
72	u64 qc_change;	72	u64 qc_change;
73	u32 qc_flags; /* GFS2_QCF_... */	73	u32 qc_flags; /* GFS2_QCF_... */
74	u32 qc_id;	74	u32 qc_id;
75	};	75	};
76		76
77	static LIST_HEAD(qd_lru_list);	77	static LIST_HEAD(qd_lru_list);
78	static atomic_t qd_lru_count = ATOMIC_INIT(0);	78	static atomic_t qd_lru_count = ATOMIC_INIT(0);
79	static DEFINE_SPINLOCK(qd_lru_lock);	79	static DEFINE_SPINLOCK(qd_lru_lock);
80		80
81	int gfs2_shrink_qd_memory(struct shrinker shrink, struct shrink_control sc)	81	int gfs2_shrink_qd_memory(struct shrinker shrink, struct shrink_control sc)
82	{	82	{
83	struct gfs2_quota_data *qd;	83	struct gfs2_quota_data *qd;
84	struct gfs2_sbd *sdp;	84	struct gfs2_sbd *sdp;
85	int nr_to_scan = sc->nr_to_scan;	85	int nr_to_scan = sc->nr_to_scan;
86		86
87	if (nr_to_scan == 0)	87	if (nr_to_scan == 0)
88	goto out;	88	goto out;
89		89
90	if (!(sc->gfp_mask & __GFP_FS))	90	if (!(sc->gfp_mask & __GFP_FS))
91	return -1;	91	return -1;
92		92
93	spin_lock(&qd_lru_lock);	93	spin_lock(&qd_lru_lock);
94	while (nr_to_scan && !list_empty(&qd_lru_list)) {	94	while (nr_to_scan && !list_empty(&qd_lru_list)) {
95	qd = list_entry(qd_lru_list.next,	95	qd = list_entry(qd_lru_list.next,
96	struct gfs2_quota_data, qd_reclaim);	96	struct gfs2_quota_data, qd_reclaim);
97	sdp = qd->qd_gl->gl_sbd;	97	sdp = qd->qd_gl->gl_sbd;
98		98
99	/* Free from the filesystem-specific list */	99	/* Free from the filesystem-specific list */
100	list_del(&qd->qd_list);	100	list_del(&qd->qd_list);
101		101
102	gfs2_assert_warn(sdp, !qd->qd_change);	102	gfs2_assert_warn(sdp, !qd->qd_change);
103	gfs2_assert_warn(sdp, !qd->qd_slot_count);	103	gfs2_assert_warn(sdp, !qd->qd_slot_count);
104	gfs2_assert_warn(sdp, !qd->qd_bh_count);	104	gfs2_assert_warn(sdp, !qd->qd_bh_count);
105		105
106	gfs2_glock_put(qd->qd_gl);	106	gfs2_glock_put(qd->qd_gl);
107	atomic_dec(&sdp->sd_quota_count);	107	atomic_dec(&sdp->sd_quota_count);
108		108
109	/* Delete it from the common reclaim list */	109	/* Delete it from the common reclaim list */
110	list_del_init(&qd->qd_reclaim);	110	list_del_init(&qd->qd_reclaim);
111	atomic_dec(&qd_lru_count);	111	atomic_dec(&qd_lru_count);
112	spin_unlock(&qd_lru_lock);	112	spin_unlock(&qd_lru_lock);
113	kmem_cache_free(gfs2_quotad_cachep, qd);	113	kmem_cache_free(gfs2_quotad_cachep, qd);
114	spin_lock(&qd_lru_lock);	114	spin_lock(&qd_lru_lock);
115	nr_to_scan--;	115	nr_to_scan--;
116	}	116	}
117	spin_unlock(&qd_lru_lock);	117	spin_unlock(&qd_lru_lock);
118		118
119	out:	119	out:
120	return (atomic_read(&qd_lru_count) * sysctl_vfs_cache_pressure) / 100;	120	return (atomic_read(&qd_lru_count) * sysctl_vfs_cache_pressure) / 100;
121	}	121	}
122		122
123	static u64 qd2offset(struct gfs2_quota_data *qd)	123	static u64 qd2offset(struct gfs2_quota_data *qd)
124	{	124	{
125	u64 offset;	125	u64 offset;
126		126
127	offset = 2 * (u64)qd->qd_id + !test_bit(QDF_USER, &qd->qd_flags);	127	offset = 2 * (u64)qd->qd_id + !test_bit(QDF_USER, &qd->qd_flags);
128	offset *= sizeof(struct gfs2_quota);	128	offset *= sizeof(struct gfs2_quota);
129		129
130	return offset;	130	return offset;
131	}	131	}
132		132
133	static int qd_alloc(struct gfs2_sbd *sdp, int user, u32 id,	133	static int qd_alloc(struct gfs2_sbd *sdp, int user, u32 id,
134	struct gfs2_quota_data **qdp)	134	struct gfs2_quota_data **qdp)
135	{	135	{
136	struct gfs2_quota_data *qd;	136	struct gfs2_quota_data *qd;
137	int error;	137	int error;
138		138
139	qd = kmem_cache_zalloc(gfs2_quotad_cachep, GFP_NOFS);	139	qd = kmem_cache_zalloc(gfs2_quotad_cachep, GFP_NOFS);
140	if (!qd)	140	if (!qd)
141	return -ENOMEM;	141	return -ENOMEM;
142		142
143	atomic_set(&qd->qd_count, 1);	143	atomic_set(&qd->qd_count, 1);
144	qd->qd_id = id;	144	qd->qd_id = id;
145	if (user)	145	if (user)
146	set_bit(QDF_USER, &qd->qd_flags);	146	set_bit(QDF_USER, &qd->qd_flags);
147	qd->qd_slot = -1;	147	qd->qd_slot = -1;
148	INIT_LIST_HEAD(&qd->qd_reclaim);	148	INIT_LIST_HEAD(&qd->qd_reclaim);
149		149
150	error = gfs2_glock_get(sdp, 2 * (u64)id + !user,	150	error = gfs2_glock_get(sdp, 2 * (u64)id + !user,
151	&gfs2_quota_glops, CREATE, &qd->qd_gl);	151	&gfs2_quota_glops, CREATE, &qd->qd_gl);
152	if (error)	152	if (error)
153	goto fail;	153	goto fail;
154		154
155	*qdp = qd;	155	*qdp = qd;
156		156
157	return 0;	157	return 0;
158		158
159	fail:	159	fail:
160	kmem_cache_free(gfs2_quotad_cachep, qd);	160	kmem_cache_free(gfs2_quotad_cachep, qd);
161	return error;	161	return error;
162	}	162	}
163		163
164	static int qd_get(struct gfs2_sbd *sdp, int user, u32 id,	164	static int qd_get(struct gfs2_sbd *sdp, int user, u32 id,
165	struct gfs2_quota_data **qdp)	165	struct gfs2_quota_data **qdp)
166	{	166	{
167	struct gfs2_quota_data qd = NULL, new_qd = NULL;	167	struct gfs2_quota_data qd = NULL, new_qd = NULL;
168	int error, found;	168	int error, found;
169		169
170	*qdp = NULL;	170	*qdp = NULL;
171		171
172	for (;;) {	172	for (;;) {
173	found = 0;	173	found = 0;
174	spin_lock(&qd_lru_lock);	174	spin_lock(&qd_lru_lock);
175	list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {	175	list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
176	if (qd->qd_id == id &&	176	if (qd->qd_id == id &&
177	!test_bit(QDF_USER, &qd->qd_flags) == !user) {	177	!test_bit(QDF_USER, &qd->qd_flags) == !user) {
178	if (!atomic_read(&qd->qd_count) &&	178	if (!atomic_read(&qd->qd_count) &&
179	!list_empty(&qd->qd_reclaim)) {	179	!list_empty(&qd->qd_reclaim)) {
180	/* Remove it from reclaim list */	180	/* Remove it from reclaim list */
181	list_del_init(&qd->qd_reclaim);	181	list_del_init(&qd->qd_reclaim);
182	atomic_dec(&qd_lru_count);	182	atomic_dec(&qd_lru_count);
183	}	183	}
184	atomic_inc(&qd->qd_count);	184	atomic_inc(&qd->qd_count);
185	found = 1;	185	found = 1;
186	break;	186	break;
187	}	187	}
188	}	188	}
189		189
190	if (!found)	190	if (!found)
191	qd = NULL;	191	qd = NULL;
192		192
193	if (!qd && new_qd) {	193	if (!qd && new_qd) {
194	qd = new_qd;	194	qd = new_qd;
195	list_add(&qd->qd_list, &sdp->sd_quota_list);	195	list_add(&qd->qd_list, &sdp->sd_quota_list);
196	atomic_inc(&sdp->sd_quota_count);	196	atomic_inc(&sdp->sd_quota_count);
197	new_qd = NULL;	197	new_qd = NULL;
198	}	198	}
199		199
200	spin_unlock(&qd_lru_lock);	200	spin_unlock(&qd_lru_lock);
201		201
202	if (qd) {	202	if (qd) {
203	if (new_qd) {	203	if (new_qd) {
204	gfs2_glock_put(new_qd->qd_gl);	204	gfs2_glock_put(new_qd->qd_gl);
205	kmem_cache_free(gfs2_quotad_cachep, new_qd);	205	kmem_cache_free(gfs2_quotad_cachep, new_qd);
206	}	206	}
207	*qdp = qd;	207	*qdp = qd;
208	return 0;	208	return 0;
209	}	209	}
210		210
211	error = qd_alloc(sdp, user, id, &new_qd);	211	error = qd_alloc(sdp, user, id, &new_qd);
212	if (error)	212	if (error)
213	return error;	213	return error;
214	}	214	}
215	}	215	}
216		216
217	static void qd_hold(struct gfs2_quota_data *qd)	217	static void qd_hold(struct gfs2_quota_data *qd)
218	{	218	{
219	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;	219	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
220	gfs2_assert(sdp, atomic_read(&qd->qd_count));	220	gfs2_assert(sdp, atomic_read(&qd->qd_count));
221	atomic_inc(&qd->qd_count);	221	atomic_inc(&qd->qd_count);
222	}	222	}
223		223
224	static void qd_put(struct gfs2_quota_data *qd)	224	static void qd_put(struct gfs2_quota_data *qd)
225	{	225	{
226	if (atomic_dec_and_lock(&qd->qd_count, &qd_lru_lock)) {	226	if (atomic_dec_and_lock(&qd->qd_count, &qd_lru_lock)) {
227	/* Add to the reclaim list */	227	/* Add to the reclaim list */
228	list_add_tail(&qd->qd_reclaim, &qd_lru_list);	228	list_add_tail(&qd->qd_reclaim, &qd_lru_list);
229	atomic_inc(&qd_lru_count);	229	atomic_inc(&qd_lru_count);
230	spin_unlock(&qd_lru_lock);	230	spin_unlock(&qd_lru_lock);
231	}	231	}
232	}	232	}
233		233
234	static int slot_get(struct gfs2_quota_data *qd)	234	static int slot_get(struct gfs2_quota_data *qd)
235	{	235	{
236	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;	236	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
237	unsigned int c, o = 0, b;	237	unsigned int c, o = 0, b;
238	unsigned char byte = 0;	238	unsigned char byte = 0;
239		239
240	spin_lock(&qd_lru_lock);	240	spin_lock(&qd_lru_lock);
241		241
242	if (qd->qd_slot_count++) {	242	if (qd->qd_slot_count++) {
243	spin_unlock(&qd_lru_lock);	243	spin_unlock(&qd_lru_lock);
244	return 0;	244	return 0;
245	}	245	}
246		246
247	for (c = 0; c < sdp->sd_quota_chunks; c++)	247	for (c = 0; c < sdp->sd_quota_chunks; c++)
248	for (o = 0; o < PAGE_SIZE; o++) {	248	for (o = 0; o < PAGE_SIZE; o++) {
249	byte = sdp->sd_quota_bitmap[c][o];	249	byte = sdp->sd_quota_bitmap[c][o];
250	if (byte != 0xFF)	250	if (byte != 0xFF)
251	goto found;	251	goto found;
252	}	252	}
253		253
254	goto fail;	254	goto fail;
255		255
256	found:	256	found:
257	for (b = 0; b < 8; b++)	257	for (b = 0; b < 8; b++)
258	if (!(byte & (1 << b)))	258	if (!(byte & (1 << b)))
259	break;	259	break;
260	qd->qd_slot = c * (8 * PAGE_SIZE) + o * 8 + b;	260	qd->qd_slot = c * (8 * PAGE_SIZE) + o * 8 + b;
261		261
262	if (qd->qd_slot >= sdp->sd_quota_slots)	262	if (qd->qd_slot >= sdp->sd_quota_slots)
263	goto fail;	263	goto fail;
264		264
265	sdp->sd_quota_bitmap[c][o] \|= 1 << b;	265	sdp->sd_quota_bitmap[c][o] \|= 1 << b;
266		266
267	spin_unlock(&qd_lru_lock);	267	spin_unlock(&qd_lru_lock);
268		268
269	return 0;	269	return 0;
270		270
271	fail:	271	fail:
272	qd->qd_slot_count--;	272	qd->qd_slot_count--;
273	spin_unlock(&qd_lru_lock);	273	spin_unlock(&qd_lru_lock);
274	return -ENOSPC;	274	return -ENOSPC;
275	}	275	}
276		276
277	static void slot_hold(struct gfs2_quota_data *qd)	277	static void slot_hold(struct gfs2_quota_data *qd)
278	{	278	{
279	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;	279	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
280		280
281	spin_lock(&qd_lru_lock);	281	spin_lock(&qd_lru_lock);
282	gfs2_assert(sdp, qd->qd_slot_count);	282	gfs2_assert(sdp, qd->qd_slot_count);
283	qd->qd_slot_count++;	283	qd->qd_slot_count++;
284	spin_unlock(&qd_lru_lock);	284	spin_unlock(&qd_lru_lock);
285	}	285	}
286		286
287	static void slot_put(struct gfs2_quota_data *qd)	287	static void slot_put(struct gfs2_quota_data *qd)
288	{	288	{
289	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;	289	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
290		290
291	spin_lock(&qd_lru_lock);	291	spin_lock(&qd_lru_lock);
292	gfs2_assert(sdp, qd->qd_slot_count);	292	gfs2_assert(sdp, qd->qd_slot_count);
293	if (!--qd->qd_slot_count) {	293	if (!--qd->qd_slot_count) {
294	gfs2_icbit_munge(sdp, sdp->sd_quota_bitmap, qd->qd_slot, 0);	294	gfs2_icbit_munge(sdp, sdp->sd_quota_bitmap, qd->qd_slot, 0);
295	qd->qd_slot = -1;	295	qd->qd_slot = -1;
296	}	296	}
297	spin_unlock(&qd_lru_lock);	297	spin_unlock(&qd_lru_lock);
298	}	298	}
299		299
300	static int bh_get(struct gfs2_quota_data *qd)	300	static int bh_get(struct gfs2_quota_data *qd)
301	{	301	{
302	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;	302	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
303	struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);	303	struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
304	unsigned int block, offset;	304	unsigned int block, offset;
305	struct buffer_head *bh;	305	struct buffer_head *bh;
306	int error;	306	int error;
307	struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };	307	struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
308		308
309	mutex_lock(&sdp->sd_quota_mutex);	309	mutex_lock(&sdp->sd_quota_mutex);
310		310
311	if (qd->qd_bh_count++) {	311	if (qd->qd_bh_count++) {
312	mutex_unlock(&sdp->sd_quota_mutex);	312	mutex_unlock(&sdp->sd_quota_mutex);
313	return 0;	313	return 0;
314	}	314	}
315		315
316	block = qd->qd_slot / sdp->sd_qc_per_block;	316	block = qd->qd_slot / sdp->sd_qc_per_block;
317	offset = qd->qd_slot % sdp->sd_qc_per_block;	317	offset = qd->qd_slot % sdp->sd_qc_per_block;
318		318
319	bh_map.b_size = 1 << ip->i_inode.i_blkbits;	319	bh_map.b_size = 1 << ip->i_inode.i_blkbits;
320	error = gfs2_block_map(&ip->i_inode, block, &bh_map, 0);	320	error = gfs2_block_map(&ip->i_inode, block, &bh_map, 0);
321	if (error)	321	if (error)
322	goto fail;	322	goto fail;
323	error = gfs2_meta_read(ip->i_gl, bh_map.b_blocknr, DIO_WAIT, &bh);	323	error = gfs2_meta_read(ip->i_gl, bh_map.b_blocknr, DIO_WAIT, &bh);
324	if (error)	324	if (error)
325	goto fail;	325	goto fail;
326	error = -EIO;	326	error = -EIO;
327	if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC))	327	if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC))
328	goto fail_brelse;	328	goto fail_brelse;
329		329
330	qd->qd_bh = bh;	330	qd->qd_bh = bh;
331	qd->qd_bh_qc = (struct gfs2_quota_change *)	331	qd->qd_bh_qc = (struct gfs2_quota_change *)
332	(bh->b_data + sizeof(struct gfs2_meta_header) +	332	(bh->b_data + sizeof(struct gfs2_meta_header) +
333	offset * sizeof(struct gfs2_quota_change));	333	offset * sizeof(struct gfs2_quota_change));
334		334
335	mutex_unlock(&sdp->sd_quota_mutex);	335	mutex_unlock(&sdp->sd_quota_mutex);
336		336
337	return 0;	337	return 0;
338		338
339	fail_brelse:	339	fail_brelse:
340	brelse(bh);	340	brelse(bh);
341	fail:	341	fail:
342	qd->qd_bh_count--;	342	qd->qd_bh_count--;
343	mutex_unlock(&sdp->sd_quota_mutex);	343	mutex_unlock(&sdp->sd_quota_mutex);
344	return error;	344	return error;
345	}	345	}
346		346
347	static void bh_put(struct gfs2_quota_data *qd)	347	static void bh_put(struct gfs2_quota_data *qd)
348	{	348	{
349	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;	349	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
350		350
351	mutex_lock(&sdp->sd_quota_mutex);	351	mutex_lock(&sdp->sd_quota_mutex);
352	gfs2_assert(sdp, qd->qd_bh_count);	352	gfs2_assert(sdp, qd->qd_bh_count);
353	if (!--qd->qd_bh_count) {	353	if (!--qd->qd_bh_count) {
354	brelse(qd->qd_bh);	354	brelse(qd->qd_bh);
355	qd->qd_bh = NULL;	355	qd->qd_bh = NULL;
356	qd->qd_bh_qc = NULL;	356	qd->qd_bh_qc = NULL;
357	}	357	}
358	mutex_unlock(&sdp->sd_quota_mutex);	358	mutex_unlock(&sdp->sd_quota_mutex);
359	}	359	}
360		360
361	static int qd_fish(struct gfs2_sbd sdp, struct gfs2_quota_data *qdp)	361	static int qd_fish(struct gfs2_sbd sdp, struct gfs2_quota_data *qdp)
362	{	362	{
363	struct gfs2_quota_data *qd = NULL;	363	struct gfs2_quota_data *qd = NULL;
364	int error;	364	int error;
365	int found = 0;	365	int found = 0;
366		366
367	*qdp = NULL;	367	*qdp = NULL;
368		368
369	if (sdp->sd_vfs->s_flags & MS_RDONLY)	369	if (sdp->sd_vfs->s_flags & MS_RDONLY)
370	return 0;	370	return 0;
371		371
372	spin_lock(&qd_lru_lock);	372	spin_lock(&qd_lru_lock);
373		373
374	list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {	374	list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
375	if (test_bit(QDF_LOCKED, &qd->qd_flags) \|\|	375	if (test_bit(QDF_LOCKED, &qd->qd_flags) \|\|
376	!test_bit(QDF_CHANGE, &qd->qd_flags) \|\|	376	!test_bit(QDF_CHANGE, &qd->qd_flags) \|\|
377	qd->qd_sync_gen >= sdp->sd_quota_sync_gen)	377	qd->qd_sync_gen >= sdp->sd_quota_sync_gen)
378	continue;	378	continue;
379		379
380	list_move_tail(&qd->qd_list, &sdp->sd_quota_list);	380	list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
381		381
382	set_bit(QDF_LOCKED, &qd->qd_flags);	382	set_bit(QDF_LOCKED, &qd->qd_flags);
383	gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));	383	gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));
384	atomic_inc(&qd->qd_count);	384	atomic_inc(&qd->qd_count);
385	qd->qd_change_sync = qd->qd_change;	385	qd->qd_change_sync = qd->qd_change;
386	gfs2_assert_warn(sdp, qd->qd_slot_count);	386	gfs2_assert_warn(sdp, qd->qd_slot_count);
387	qd->qd_slot_count++;	387	qd->qd_slot_count++;
388	found = 1;	388	found = 1;
389		389
390	break;	390	break;
391	}	391	}
392		392
393	if (!found)	393	if (!found)
394	qd = NULL;	394	qd = NULL;
395		395
396	spin_unlock(&qd_lru_lock);	396	spin_unlock(&qd_lru_lock);
397		397
398	if (qd) {	398	if (qd) {
399	gfs2_assert_warn(sdp, qd->qd_change_sync);	399	gfs2_assert_warn(sdp, qd->qd_change_sync);
400	error = bh_get(qd);	400	error = bh_get(qd);
401	if (error) {	401	if (error) {
402	clear_bit(QDF_LOCKED, &qd->qd_flags);	402	clear_bit(QDF_LOCKED, &qd->qd_flags);
403	slot_put(qd);	403	slot_put(qd);
404	qd_put(qd);	404	qd_put(qd);
405	return error;	405	return error;
406	}	406	}
407	}	407	}
408		408
409	*qdp = qd;	409	*qdp = qd;
410		410
411	return 0;	411	return 0;
412	}	412	}
413		413
414	static int qd_trylock(struct gfs2_quota_data *qd)	414	static int qd_trylock(struct gfs2_quota_data *qd)
415	{	415	{
416	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;	416	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
417		417
418	if (sdp->sd_vfs->s_flags & MS_RDONLY)	418	if (sdp->sd_vfs->s_flags & MS_RDONLY)
419	return 0;	419	return 0;
420		420
421	spin_lock(&qd_lru_lock);	421	spin_lock(&qd_lru_lock);
422		422
423	if (test_bit(QDF_LOCKED, &qd->qd_flags) \|\|	423	if (test_bit(QDF_LOCKED, &qd->qd_flags) \|\|
424	!test_bit(QDF_CHANGE, &qd->qd_flags)) {	424	!test_bit(QDF_CHANGE, &qd->qd_flags)) {
425	spin_unlock(&qd_lru_lock);	425	spin_unlock(&qd_lru_lock);
426	return 0;	426	return 0;
427	}	427	}
428		428
429	list_move_tail(&qd->qd_list, &sdp->sd_quota_list);	429	list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
430		430
431	set_bit(QDF_LOCKED, &qd->qd_flags);	431	set_bit(QDF_LOCKED, &qd->qd_flags);
432	gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));	432	gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));
433	atomic_inc(&qd->qd_count);	433	atomic_inc(&qd->qd_count);
434	qd->qd_change_sync = qd->qd_change;	434	qd->qd_change_sync = qd->qd_change;
435	gfs2_assert_warn(sdp, qd->qd_slot_count);	435	gfs2_assert_warn(sdp, qd->qd_slot_count);
436	qd->qd_slot_count++;	436	qd->qd_slot_count++;
437		437
438	spin_unlock(&qd_lru_lock);	438	spin_unlock(&qd_lru_lock);
439		439
440	gfs2_assert_warn(sdp, qd->qd_change_sync);	440	gfs2_assert_warn(sdp, qd->qd_change_sync);
441	if (bh_get(qd)) {	441	if (bh_get(qd)) {
442	clear_bit(QDF_LOCKED, &qd->qd_flags);	442	clear_bit(QDF_LOCKED, &qd->qd_flags);
443	slot_put(qd);	443	slot_put(qd);
444	qd_put(qd);	444	qd_put(qd);
445	return 0;	445	return 0;
446	}	446	}
447		447
448	return 1;	448	return 1;
449	}	449	}
450		450
451	static void qd_unlock(struct gfs2_quota_data *qd)	451	static void qd_unlock(struct gfs2_quota_data *qd)
452	{	452	{
453	gfs2_assert_warn(qd->qd_gl->gl_sbd,	453	gfs2_assert_warn(qd->qd_gl->gl_sbd,
454	test_bit(QDF_LOCKED, &qd->qd_flags));	454	test_bit(QDF_LOCKED, &qd->qd_flags));
455	clear_bit(QDF_LOCKED, &qd->qd_flags);	455	clear_bit(QDF_LOCKED, &qd->qd_flags);
456	bh_put(qd);	456	bh_put(qd);
457	slot_put(qd);	457	slot_put(qd);
458	qd_put(qd);	458	qd_put(qd);
459	}	459	}
460		460
461	static int qdsb_get(struct gfs2_sbd *sdp, int user, u32 id,	461	static int qdsb_get(struct gfs2_sbd *sdp, int user, u32 id,
462	struct gfs2_quota_data **qdp)	462	struct gfs2_quota_data **qdp)
463	{	463	{
464	int error;	464	int error;
465		465
466	error = qd_get(sdp, user, id, qdp);	466	error = qd_get(sdp, user, id, qdp);
467	if (error)	467	if (error)
468	return error;	468	return error;
469		469
470	error = slot_get(*qdp);	470	error = slot_get(*qdp);
471	if (error)	471	if (error)
472	goto fail;	472	goto fail;
473		473
474	error = bh_get(*qdp);	474	error = bh_get(*qdp);
475	if (error)	475	if (error)
476	goto fail_slot;	476	goto fail_slot;
477		477
478	return 0;	478	return 0;
479		479
480	fail_slot:	480	fail_slot:
481	slot_put(*qdp);	481	slot_put(*qdp);
482	fail:	482	fail:
483	qd_put(*qdp);	483	qd_put(*qdp);
484	return error;	484	return error;
485	}	485	}
486		486
487	static void qdsb_put(struct gfs2_quota_data *qd)	487	static void qdsb_put(struct gfs2_quota_data *qd)
488	{	488	{
489	bh_put(qd);	489	bh_put(qd);
490	slot_put(qd);	490	slot_put(qd);
491	qd_put(qd);	491	qd_put(qd);
492	}	492	}
493		493
494	int gfs2_quota_hold(struct gfs2_inode *ip, u32 uid, u32 gid)	494	int gfs2_quota_hold(struct gfs2_inode *ip, u32 uid, u32 gid)
495	{	495	{
496	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	496	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
497	struct gfs2_quota_data **qd;	497	struct gfs2_quota_data **qd;
498	int error;	498	int error;
499		499
500	if (ip->i_res == NULL) {	500	if (ip->i_res == NULL) {
501	error = gfs2_rs_alloc(ip);	501	error = gfs2_rs_alloc(ip);
502	if (error)	502	if (error)
503	return error;	503	return error;
504	}	504	}
505		505
506	qd = ip->i_res->rs_qa_qd;	506	qd = ip->i_res->rs_qa_qd;
507		507
508	if (gfs2_assert_warn(sdp, !ip->i_res->rs_qa_qd_num) \|\|	508	if (gfs2_assert_warn(sdp, !ip->i_res->rs_qa_qd_num) \|\|
509	gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags)))	509	gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags)))
510	return -EIO;	510	return -EIO;
511		511
512	if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)	512	if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
513	return 0;	513	return 0;
514		514
515	error = qdsb_get(sdp, QUOTA_USER, ip->i_inode.i_uid, qd);	515	error = qdsb_get(sdp, QUOTA_USER, ip->i_inode.i_uid, qd);
516	if (error)	516	if (error)
517	goto out;	517	goto out;
518	ip->i_res->rs_qa_qd_num++;	518	ip->i_res->rs_qa_qd_num++;
519	qd++;	519	qd++;
520		520
521	error = qdsb_get(sdp, QUOTA_GROUP, ip->i_inode.i_gid, qd);	521	error = qdsb_get(sdp, QUOTA_GROUP, ip->i_inode.i_gid, qd);
522	if (error)	522	if (error)
523	goto out;	523	goto out;
524	ip->i_res->rs_qa_qd_num++;	524	ip->i_res->rs_qa_qd_num++;
525	qd++;	525	qd++;
526		526
527	if (uid != NO_QUOTA_CHANGE && uid != ip->i_inode.i_uid) {	527	if (uid != NO_QUOTA_CHANGE && uid != ip->i_inode.i_uid) {
528	error = qdsb_get(sdp, QUOTA_USER, uid, qd);	528	error = qdsb_get(sdp, QUOTA_USER, uid, qd);
529	if (error)	529	if (error)
530	goto out;	530	goto out;
531	ip->i_res->rs_qa_qd_num++;	531	ip->i_res->rs_qa_qd_num++;
532	qd++;	532	qd++;
533	}	533	}
534		534
535	if (gid != NO_QUOTA_CHANGE && gid != ip->i_inode.i_gid) {	535	if (gid != NO_QUOTA_CHANGE && gid != ip->i_inode.i_gid) {
536	error = qdsb_get(sdp, QUOTA_GROUP, gid, qd);	536	error = qdsb_get(sdp, QUOTA_GROUP, gid, qd);
537	if (error)	537	if (error)
538	goto out;	538	goto out;
539	ip->i_res->rs_qa_qd_num++;	539	ip->i_res->rs_qa_qd_num++;
540	qd++;	540	qd++;
541	}	541	}
542		542
543	out:	543	out:
544	if (error)	544	if (error)
545	gfs2_quota_unhold(ip);	545	gfs2_quota_unhold(ip);
546	return error;	546	return error;
547	}	547	}
548		548
549	void gfs2_quota_unhold(struct gfs2_inode *ip)	549	void gfs2_quota_unhold(struct gfs2_inode *ip)
550	{	550	{
551	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	551	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
552	unsigned int x;	552	unsigned int x;
553		553
554	if (ip->i_res == NULL)	554	if (ip->i_res == NULL)
555	return;	555	return;
556	gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags));	556	gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags));
557		557
558	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {	558	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
559	qdsb_put(ip->i_res->rs_qa_qd[x]);	559	qdsb_put(ip->i_res->rs_qa_qd[x]);
560	ip->i_res->rs_qa_qd[x] = NULL;	560	ip->i_res->rs_qa_qd[x] = NULL;
561	}	561	}
562	ip->i_res->rs_qa_qd_num = 0;	562	ip->i_res->rs_qa_qd_num = 0;
563	}	563	}
564		564
565	static int sort_qd(const void a, const void b)	565	static int sort_qd(const void a, const void b)
566	{	566	{
567	const struct gfs2_quota_data qd_a = (const struct gfs2_quota_data **)a;	567	const struct gfs2_quota_data qd_a = (const struct gfs2_quota_data **)a;
568	const struct gfs2_quota_data qd_b = (const struct gfs2_quota_data **)b;	568	const struct gfs2_quota_data qd_b = (const struct gfs2_quota_data **)b;
569		569
570	if (!test_bit(QDF_USER, &qd_a->qd_flags) !=	570	if (!test_bit(QDF_USER, &qd_a->qd_flags) !=
571	!test_bit(QDF_USER, &qd_b->qd_flags)) {	571	!test_bit(QDF_USER, &qd_b->qd_flags)) {
572	if (test_bit(QDF_USER, &qd_a->qd_flags))	572	if (test_bit(QDF_USER, &qd_a->qd_flags))
573	return -1;	573	return -1;
574	else	574	else
575	return 1;	575	return 1;
576	}	576	}
577	if (qd_a->qd_id < qd_b->qd_id)	577	if (qd_a->qd_id < qd_b->qd_id)
578	return -1;	578	return -1;
579	if (qd_a->qd_id > qd_b->qd_id)	579	if (qd_a->qd_id > qd_b->qd_id)
580	return 1;	580	return 1;
581		581
582	return 0;	582	return 0;
583	}	583	}
584		584
585	static void do_qc(struct gfs2_quota_data *qd, s64 change)	585	static void do_qc(struct gfs2_quota_data *qd, s64 change)
586	{	586	{
587	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;	587	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
588	struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);	588	struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
589	struct gfs2_quota_change *qc = qd->qd_bh_qc;	589	struct gfs2_quota_change *qc = qd->qd_bh_qc;
590	s64 x;	590	s64 x;
591		591
592	mutex_lock(&sdp->sd_quota_mutex);	592	mutex_lock(&sdp->sd_quota_mutex);
593	gfs2_trans_add_bh(ip->i_gl, qd->qd_bh, 1);	593	gfs2_trans_add_bh(ip->i_gl, qd->qd_bh, 1);
594		594
595	if (!test_bit(QDF_CHANGE, &qd->qd_flags)) {	595	if (!test_bit(QDF_CHANGE, &qd->qd_flags)) {
596	qc->qc_change = 0;	596	qc->qc_change = 0;
597	qc->qc_flags = 0;	597	qc->qc_flags = 0;
598	if (test_bit(QDF_USER, &qd->qd_flags))	598	if (test_bit(QDF_USER, &qd->qd_flags))
599	qc->qc_flags = cpu_to_be32(GFS2_QCF_USER);	599	qc->qc_flags = cpu_to_be32(GFS2_QCF_USER);
600	qc->qc_id = cpu_to_be32(qd->qd_id);	600	qc->qc_id = cpu_to_be32(qd->qd_id);
601	}	601	}
602		602
603	x = be64_to_cpu(qc->qc_change) + change;	603	x = be64_to_cpu(qc->qc_change) + change;
604	qc->qc_change = cpu_to_be64(x);	604	qc->qc_change = cpu_to_be64(x);
605		605
606	spin_lock(&qd_lru_lock);	606	spin_lock(&qd_lru_lock);
607	qd->qd_change = x;	607	qd->qd_change = x;
608	spin_unlock(&qd_lru_lock);	608	spin_unlock(&qd_lru_lock);
609		609
610	if (!x) {	610	if (!x) {
611	gfs2_assert_warn(sdp, test_bit(QDF_CHANGE, &qd->qd_flags));	611	gfs2_assert_warn(sdp, test_bit(QDF_CHANGE, &qd->qd_flags));
612	clear_bit(QDF_CHANGE, &qd->qd_flags);	612	clear_bit(QDF_CHANGE, &qd->qd_flags);
613	qc->qc_flags = 0;	613	qc->qc_flags = 0;
614	qc->qc_id = 0;	614	qc->qc_id = 0;
615	slot_put(qd);	615	slot_put(qd);
616	qd_put(qd);	616	qd_put(qd);
617	} else if (!test_and_set_bit(QDF_CHANGE, &qd->qd_flags)) {	617	} else if (!test_and_set_bit(QDF_CHANGE, &qd->qd_flags)) {
618	qd_hold(qd);	618	qd_hold(qd);
619	slot_hold(qd);	619	slot_hold(qd);
620	}	620	}
621		621
622	mutex_unlock(&sdp->sd_quota_mutex);	622	mutex_unlock(&sdp->sd_quota_mutex);
623	}	623	}
624		624
625	/**	625	/**
626	* gfs2_adjust_quota - adjust record of current block usage	626	* gfs2_adjust_quota - adjust record of current block usage
627	* @ip: The quota inode	627	* @ip: The quota inode
628	* @loc: Offset of the entry in the quota file	628	* @loc: Offset of the entry in the quota file
629	* @change: The amount of usage change to record	629	* @change: The amount of usage change to record
630	* @qd: The quota data	630	* @qd: The quota data
631	* @fdq: The updated limits to record	631	* @fdq: The updated limits to record
632	*	632	*
633	* This function was mostly borrowed from gfs2_block_truncate_page which was	633	* This function was mostly borrowed from gfs2_block_truncate_page which was
634	* in turn mostly borrowed from ext3	634	* in turn mostly borrowed from ext3
635	*	635	*
636	* Returns: 0 or -ve on error	636	* Returns: 0 or -ve on error
637	*/	637	*/
638		638
639	static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,	639	static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
640	s64 change, struct gfs2_quota_data *qd,	640	s64 change, struct gfs2_quota_data *qd,
641	struct fs_disk_quota *fdq)	641	struct fs_disk_quota *fdq)
642	{	642	{
643	struct inode *inode = &ip->i_inode;	643	struct inode *inode = &ip->i_inode;
644	struct gfs2_sbd *sdp = GFS2_SB(inode);	644	struct gfs2_sbd *sdp = GFS2_SB(inode);
645	struct address_space *mapping = inode->i_mapping;	645	struct address_space *mapping = inode->i_mapping;
646	unsigned long index = loc >> PAGE_CACHE_SHIFT;	646	unsigned long index = loc >> PAGE_CACHE_SHIFT;
647	unsigned offset = loc & (PAGE_CACHE_SIZE - 1);	647	unsigned offset = loc & (PAGE_CACHE_SIZE - 1);
648	unsigned blocksize, iblock, pos;	648	unsigned blocksize, iblock, pos;
649	struct buffer_head *bh;	649	struct buffer_head *bh;
650	struct page *page;	650	struct page *page;
651	void kaddr, ptr;	651	void kaddr, ptr;
652	struct gfs2_quota q, *qp;	652	struct gfs2_quota q, *qp;
653	int err, nbytes;	653	int err, nbytes;
654	u64 size;	654	u64 size;
655		655
656	if (gfs2_is_stuffed(ip)) {	656	if (gfs2_is_stuffed(ip)) {
657	err = gfs2_unstuff_dinode(ip, NULL);	657	err = gfs2_unstuff_dinode(ip, NULL);
658	if (err)	658	if (err)
659	return err;	659	return err;
660	}	660	}
661		661
662	memset(&q, 0, sizeof(struct gfs2_quota));	662	memset(&q, 0, sizeof(struct gfs2_quota));
663	err = gfs2_internal_read(ip, (char *)&q, &loc, sizeof(q));	663	err = gfs2_internal_read(ip, (char *)&q, &loc, sizeof(q));
664	if (err < 0)	664	if (err < 0)
665	return err;	665	return err;
666		666
667	err = -EIO;	667	err = -EIO;
668	qp = &q;	668	qp = &q;
669	qp->qu_value = be64_to_cpu(qp->qu_value);	669	qp->qu_value = be64_to_cpu(qp->qu_value);
670	qp->qu_value += change;	670	qp->qu_value += change;
671	qp->qu_value = cpu_to_be64(qp->qu_value);	671	qp->qu_value = cpu_to_be64(qp->qu_value);
672	qd->qd_qb.qb_value = qp->qu_value;	672	qd->qd_qb.qb_value = qp->qu_value;
673	if (fdq) {	673	if (fdq) {
674	if (fdq->d_fieldmask & FS_DQ_BSOFT) {	674	if (fdq->d_fieldmask & FS_DQ_BSOFT) {
675	qp->qu_warn = cpu_to_be64(fdq->d_blk_softlimit >> sdp->sd_fsb2bb_shift);	675	qp->qu_warn = cpu_to_be64(fdq->d_blk_softlimit >> sdp->sd_fsb2bb_shift);
676	qd->qd_qb.qb_warn = qp->qu_warn;	676	qd->qd_qb.qb_warn = qp->qu_warn;
677	}	677	}
678	if (fdq->d_fieldmask & FS_DQ_BHARD) {	678	if (fdq->d_fieldmask & FS_DQ_BHARD) {
679	qp->qu_limit = cpu_to_be64(fdq->d_blk_hardlimit >> sdp->sd_fsb2bb_shift);	679	qp->qu_limit = cpu_to_be64(fdq->d_blk_hardlimit >> sdp->sd_fsb2bb_shift);
680	qd->qd_qb.qb_limit = qp->qu_limit;	680	qd->qd_qb.qb_limit = qp->qu_limit;
681	}	681	}
682	if (fdq->d_fieldmask & FS_DQ_BCOUNT) {	682	if (fdq->d_fieldmask & FS_DQ_BCOUNT) {
683	qp->qu_value = cpu_to_be64(fdq->d_bcount >> sdp->sd_fsb2bb_shift);	683	qp->qu_value = cpu_to_be64(fdq->d_bcount >> sdp->sd_fsb2bb_shift);
684	qd->qd_qb.qb_value = qp->qu_value;	684	qd->qd_qb.qb_value = qp->qu_value;
685	}	685	}
686	}	686	}
687		687
688	/* Write the quota into the quota file on disk */	688	/* Write the quota into the quota file on disk */
689	ptr = qp;	689	ptr = qp;
690	nbytes = sizeof(struct gfs2_quota);	690	nbytes = sizeof(struct gfs2_quota);
691	get_a_page:	691	get_a_page:
692	page = find_or_create_page(mapping, index, GFP_NOFS);	692	page = find_or_create_page(mapping, index, GFP_NOFS);
693	if (!page)	693	if (!page)
694	return -ENOMEM;	694	return -ENOMEM;
695		695
696	blocksize = inode->i_sb->s_blocksize;	696	blocksize = inode->i_sb->s_blocksize;
697	iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);	697	iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
698		698
699	if (!page_has_buffers(page))	699	if (!page_has_buffers(page))
700	create_empty_buffers(page, blocksize, 0);	700	create_empty_buffers(page, blocksize, 0);
701		701
702	bh = page_buffers(page);	702	bh = page_buffers(page);
703	pos = blocksize;	703	pos = blocksize;
704	while (offset >= pos) {	704	while (offset >= pos) {
705	bh = bh->b_this_page;	705	bh = bh->b_this_page;
706	iblock++;	706	iblock++;
707	pos += blocksize;	707	pos += blocksize;
708	}	708	}
709		709
710	if (!buffer_mapped(bh)) {	710	if (!buffer_mapped(bh)) {
711	gfs2_block_map(inode, iblock, bh, 1);	711	gfs2_block_map(inode, iblock, bh, 1);
712	if (!buffer_mapped(bh))	712	if (!buffer_mapped(bh))
713	goto unlock_out;	713	goto unlock_out;
714	/* If it's a newly allocated disk block for quota, zero it */	714	/* If it's a newly allocated disk block for quota, zero it */
715	if (buffer_new(bh))	715	if (buffer_new(bh))
716	zero_user(page, pos - blocksize, bh->b_size);	716	zero_user(page, pos - blocksize, bh->b_size);
717	}	717	}
718		718
719	if (PageUptodate(page))	719	if (PageUptodate(page))
720	set_buffer_uptodate(bh);	720	set_buffer_uptodate(bh);
721		721
722	if (!buffer_uptodate(bh)) {	722	if (!buffer_uptodate(bh)) {
723	ll_rw_block(READ \| REQ_META, 1, &bh);	723	ll_rw_block(READ \| REQ_META, 1, &bh);
724	wait_on_buffer(bh);	724	wait_on_buffer(bh);
725	if (!buffer_uptodate(bh))	725	if (!buffer_uptodate(bh))
726	goto unlock_out;	726	goto unlock_out;
727	}	727	}
728		728
729	gfs2_trans_add_bh(ip->i_gl, bh, 0);	729	gfs2_trans_add_bh(ip->i_gl, bh, 0);
730		730
731	kaddr = kmap_atomic(page);	731	kaddr = kmap_atomic(page);
732	if (offset + sizeof(struct gfs2_quota) > PAGE_CACHE_SIZE)	732	if (offset + sizeof(struct gfs2_quota) > PAGE_CACHE_SIZE)
733	nbytes = PAGE_CACHE_SIZE - offset;	733	nbytes = PAGE_CACHE_SIZE - offset;
734	memcpy(kaddr + offset, ptr, nbytes);	734	memcpy(kaddr + offset, ptr, nbytes);
735	flush_dcache_page(page);	735	flush_dcache_page(page);
736	kunmap_atomic(kaddr);	736	kunmap_atomic(kaddr);
737	unlock_page(page);	737	unlock_page(page);
738	page_cache_release(page);	738	page_cache_release(page);
739		739
740	/* If quota straddles page boundary, we need to update the rest of the	740	/* If quota straddles page boundary, we need to update the rest of the
741	* quota at the beginning of the next page */	741	* quota at the beginning of the next page */
742	if ((offset + sizeof(struct gfs2_quota)) > PAGE_CACHE_SIZE) {	742	if ((offset + sizeof(struct gfs2_quota)) > PAGE_CACHE_SIZE) {
743	ptr = ptr + nbytes;	743	ptr = ptr + nbytes;
744	nbytes = sizeof(struct gfs2_quota) - nbytes;	744	nbytes = sizeof(struct gfs2_quota) - nbytes;
745	offset = 0;	745	offset = 0;
746	index++;	746	index++;
747	goto get_a_page;	747	goto get_a_page;
748	}	748	}
749		749
750	size = loc + sizeof(struct gfs2_quota);	750	size = loc + sizeof(struct gfs2_quota);
751	if (size > inode->i_size)	751	if (size > inode->i_size)
752	i_size_write(inode, size);	752	i_size_write(inode, size);
753	inode->i_mtime = inode->i_atime = CURRENT_TIME;	753	inode->i_mtime = inode->i_atime = CURRENT_TIME;
754	mark_inode_dirty(inode);	754	mark_inode_dirty(inode);
755	return 0;	755	return 0;
756		756
757	unlock_out:	757	unlock_out:
758	unlock_page(page);	758	unlock_page(page);
759	page_cache_release(page);	759	page_cache_release(page);
760	return err;	760	return err;
761	}	761	}
762		762
763	static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)	763	static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
764	{	764	{
765	struct gfs2_sbd sdp = (qda)->qd_gl->gl_sbd;	765	struct gfs2_sbd sdp = (qda)->qd_gl->gl_sbd;
766	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);	766	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
767	unsigned int data_blocks, ind_blocks;	767	unsigned int data_blocks, ind_blocks;
768	struct gfs2_holder *ghs, i_gh;	768	struct gfs2_holder *ghs, i_gh;
769	unsigned int qx, x;	769	unsigned int qx, x;
770	struct gfs2_quota_data *qd;	770	struct gfs2_quota_data *qd;
771	unsigned reserved;	771	unsigned reserved;
772	loff_t offset;	772	loff_t offset;
773	unsigned int nalloc = 0, blocks;	773	unsigned int nalloc = 0, blocks;
774	int error;	774	int error;
775		775
776	error = gfs2_rs_alloc(ip);	776	error = gfs2_rs_alloc(ip);
777	if (error)	777	if (error)
778	return error;	778	return error;
779		779
780	gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),	780	gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
781	&data_blocks, &ind_blocks);	781	&data_blocks, &ind_blocks);
782		782
783	ghs = kcalloc(num_qd, sizeof(struct gfs2_holder), GFP_NOFS);	783	ghs = kcalloc(num_qd, sizeof(struct gfs2_holder), GFP_NOFS);
784	if (!ghs)	784	if (!ghs)
785	return -ENOMEM;	785	return -ENOMEM;
786		786
787	sort(qda, num_qd, sizeof(struct gfs2_quota_data *), sort_qd, NULL);	787	sort(qda, num_qd, sizeof(struct gfs2_quota_data *), sort_qd, NULL);
788	mutex_lock(&ip->i_inode.i_mutex);	788	mutex_lock(&ip->i_inode.i_mutex);
789	for (qx = 0; qx < num_qd; qx++) {	789	for (qx = 0; qx < num_qd; qx++) {
790	error = gfs2_glock_nq_init(qda[qx]->qd_gl, LM_ST_EXCLUSIVE,	790	error = gfs2_glock_nq_init(qda[qx]->qd_gl, LM_ST_EXCLUSIVE,
791	GL_NOCACHE, &ghs[qx]);	791	GL_NOCACHE, &ghs[qx]);
792	if (error)	792	if (error)
793	goto out;	793	goto out;
794	}	794	}
795		795
796	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);	796	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
797	if (error)	797	if (error)
798	goto out;	798	goto out;
799		799
800	for (x = 0; x < num_qd; x++) {	800	for (x = 0; x < num_qd; x++) {
801	offset = qd2offset(qda[x]);	801	offset = qd2offset(qda[x]);
802	if (gfs2_write_alloc_required(ip, offset,	802	if (gfs2_write_alloc_required(ip, offset,
803	sizeof(struct gfs2_quota)))	803	sizeof(struct gfs2_quota)))
804	nalloc++;	804	nalloc++;
805	}	805	}
806		806
807	/*	807	/*
808	* 1 blk for unstuffing inode if stuffed. We add this extra	808	* 1 blk for unstuffing inode if stuffed. We add this extra
809	* block to the reservation unconditionally. If the inode	809	* block to the reservation unconditionally. If the inode
810	* doesn't need unstuffing, the block will be released to the	810	* doesn't need unstuffing, the block will be released to the
811	* rgrp since it won't be allocated during the transaction	811	* rgrp since it won't be allocated during the transaction
812	*/	812	*/
813	/* +3 in the end for unstuffing block, inode size update block	813	/* +3 in the end for unstuffing block, inode size update block
814	* and another block in case quota straddles page boundary and	814	* and another block in case quota straddles page boundary and
815	* two blocks need to be updated instead of 1 */	815	* two blocks need to be updated instead of 1 */
816	blocks = num_qd * data_blocks + RES_DINODE + num_qd + 3;	816	blocks = num_qd * data_blocks + RES_DINODE + num_qd + 3;
817		817
818	reserved = 1 + (nalloc * (data_blocks + ind_blocks));	818	reserved = 1 + (nalloc * (data_blocks + ind_blocks));
819	error = gfs2_inplace_reserve(ip, reserved);	819	error = gfs2_inplace_reserve(ip, reserved, 0);
820	if (error)	820	if (error)
821	goto out_alloc;	821	goto out_alloc;
822		822
823	if (nalloc)	823	if (nalloc)
824	blocks += gfs2_rg_blocks(ip, reserved) + nalloc * ind_blocks + RES_STATFS;	824	blocks += gfs2_rg_blocks(ip, reserved) + nalloc * ind_blocks + RES_STATFS;
825		825
826	error = gfs2_trans_begin(sdp, blocks, 0);	826	error = gfs2_trans_begin(sdp, blocks, 0);
827	if (error)	827	if (error)
828	goto out_ipres;	828	goto out_ipres;
829		829
830	for (x = 0; x < num_qd; x++) {	830	for (x = 0; x < num_qd; x++) {
831	qd = qda[x];	831	qd = qda[x];
832	offset = qd2offset(qd);	832	offset = qd2offset(qd);
833	error = gfs2_adjust_quota(ip, offset, qd->qd_change_sync, qd, NULL);	833	error = gfs2_adjust_quota(ip, offset, qd->qd_change_sync, qd, NULL);
834	if (error)	834	if (error)
835	goto out_end_trans;	835	goto out_end_trans;
836		836
837	do_qc(qd, -qd->qd_change_sync);	837	do_qc(qd, -qd->qd_change_sync);
838	set_bit(QDF_REFRESH, &qd->qd_flags);	838	set_bit(QDF_REFRESH, &qd->qd_flags);
839	}	839	}
840		840
841	error = 0;	841	error = 0;
842		842
843	out_end_trans:	843	out_end_trans:
844	gfs2_trans_end(sdp);	844	gfs2_trans_end(sdp);
845	out_ipres:	845	out_ipres:
846	gfs2_inplace_release(ip);	846	gfs2_inplace_release(ip);
847	out_alloc:	847	out_alloc:
848	gfs2_glock_dq_uninit(&i_gh);	848	gfs2_glock_dq_uninit(&i_gh);
849	out:	849	out:
850	while (qx--)	850	while (qx--)
851	gfs2_glock_dq_uninit(&ghs[qx]);	851	gfs2_glock_dq_uninit(&ghs[qx]);
852	mutex_unlock(&ip->i_inode.i_mutex);	852	mutex_unlock(&ip->i_inode.i_mutex);
853	kfree(ghs);	853	kfree(ghs);
854	gfs2_log_flush(ip->i_gl->gl_sbd, ip->i_gl);	854	gfs2_log_flush(ip->i_gl->gl_sbd, ip->i_gl);
855	return error;	855	return error;
856	}	856	}
857		857
858	static int update_qd(struct gfs2_sbd sdp, struct gfs2_quota_data qd)	858	static int update_qd(struct gfs2_sbd sdp, struct gfs2_quota_data qd)
859	{	859	{
860	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);	860	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
861	struct gfs2_quota q;	861	struct gfs2_quota q;
862	struct gfs2_quota_lvb *qlvb;	862	struct gfs2_quota_lvb *qlvb;
863	loff_t pos;	863	loff_t pos;
864	int error;	864	int error;
865		865
866	memset(&q, 0, sizeof(struct gfs2_quota));	866	memset(&q, 0, sizeof(struct gfs2_quota));
867	pos = qd2offset(qd);	867	pos = qd2offset(qd);
868	error = gfs2_internal_read(ip, (char *)&q, &pos, sizeof(q));	868	error = gfs2_internal_read(ip, (char *)&q, &pos, sizeof(q));
869	if (error < 0)	869	if (error < 0)
870	return error;	870	return error;
871		871
872	qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;	872	qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;
873	qlvb->qb_magic = cpu_to_be32(GFS2_MAGIC);	873	qlvb->qb_magic = cpu_to_be32(GFS2_MAGIC);
874	qlvb->__pad = 0;	874	qlvb->__pad = 0;
875	qlvb->qb_limit = q.qu_limit;	875	qlvb->qb_limit = q.qu_limit;
876	qlvb->qb_warn = q.qu_warn;	876	qlvb->qb_warn = q.qu_warn;
877	qlvb->qb_value = q.qu_value;	877	qlvb->qb_value = q.qu_value;
878	qd->qd_qb = *qlvb;	878	qd->qd_qb = *qlvb;
879		879
880	return 0;	880	return 0;
881	}	881	}
882		882
883	static int do_glock(struct gfs2_quota_data *qd, int force_refresh,	883	static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
884	struct gfs2_holder *q_gh)	884	struct gfs2_holder *q_gh)
885	{	885	{
886	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;	886	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
887	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);	887	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
888	struct gfs2_holder i_gh;	888	struct gfs2_holder i_gh;
889	int error;	889	int error;
890		890
891	restart:	891	restart:
892	error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_SHARED, 0, q_gh);	892	error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_SHARED, 0, q_gh);
893	if (error)	893	if (error)
894	return error;	894	return error;
895		895
896	qd->qd_qb = (struct gfs2_quota_lvb )qd->qd_gl->gl_lvb;	896	qd->qd_qb = (struct gfs2_quota_lvb )qd->qd_gl->gl_lvb;
897		897
898	if (force_refresh \|\| qd->qd_qb.qb_magic != cpu_to_be32(GFS2_MAGIC)) {	898	if (force_refresh \|\| qd->qd_qb.qb_magic != cpu_to_be32(GFS2_MAGIC)) {
899	gfs2_glock_dq_uninit(q_gh);	899	gfs2_glock_dq_uninit(q_gh);
900	error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE,	900	error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE,
901	GL_NOCACHE, q_gh);	901	GL_NOCACHE, q_gh);
902	if (error)	902	if (error)
903	return error;	903	return error;
904		904
905	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);	905	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
906	if (error)	906	if (error)
907	goto fail;	907	goto fail;
908		908
909	error = update_qd(sdp, qd);	909	error = update_qd(sdp, qd);
910	if (error)	910	if (error)
911	goto fail_gunlock;	911	goto fail_gunlock;
912		912
913	gfs2_glock_dq_uninit(&i_gh);	913	gfs2_glock_dq_uninit(&i_gh);
914	gfs2_glock_dq_uninit(q_gh);	914	gfs2_glock_dq_uninit(q_gh);
915	force_refresh = 0;	915	force_refresh = 0;
916	goto restart;	916	goto restart;
917	}	917	}
918		918
919	return 0;	919	return 0;
920		920
921	fail_gunlock:	921	fail_gunlock:
922	gfs2_glock_dq_uninit(&i_gh);	922	gfs2_glock_dq_uninit(&i_gh);
923	fail:	923	fail:
924	gfs2_glock_dq_uninit(q_gh);	924	gfs2_glock_dq_uninit(q_gh);
925	return error;	925	return error;
926	}	926	}
927		927
928	int gfs2_quota_lock(struct gfs2_inode *ip, u32 uid, u32 gid)	928	int gfs2_quota_lock(struct gfs2_inode *ip, u32 uid, u32 gid)
929	{	929	{
930	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	930	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
931	struct gfs2_quota_data *qd;	931	struct gfs2_quota_data *qd;
932	unsigned int x;	932	unsigned int x;
933	int error = 0;	933	int error = 0;
934		934
935	error = gfs2_quota_hold(ip, uid, gid);	935	error = gfs2_quota_hold(ip, uid, gid);
936	if (error)	936	if (error)
937	return error;	937	return error;
938		938
939	if (capable(CAP_SYS_RESOURCE) \|\|	939	if (capable(CAP_SYS_RESOURCE) \|\|
940	sdp->sd_args.ar_quota != GFS2_QUOTA_ON)	940	sdp->sd_args.ar_quota != GFS2_QUOTA_ON)
941	return 0;	941	return 0;
942		942
943	sort(ip->i_res->rs_qa_qd, ip->i_res->rs_qa_qd_num,	943	sort(ip->i_res->rs_qa_qd, ip->i_res->rs_qa_qd_num,
944	sizeof(struct gfs2_quota_data *), sort_qd, NULL);	944	sizeof(struct gfs2_quota_data *), sort_qd, NULL);
945		945
946	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {	946	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
947	int force = NO_FORCE;	947	int force = NO_FORCE;
948	qd = ip->i_res->rs_qa_qd[x];	948	qd = ip->i_res->rs_qa_qd[x];
949	if (test_and_clear_bit(QDF_REFRESH, &qd->qd_flags))	949	if (test_and_clear_bit(QDF_REFRESH, &qd->qd_flags))
950	force = FORCE;	950	force = FORCE;
951	error = do_glock(qd, force, &ip->i_res->rs_qa_qd_ghs[x]);	951	error = do_glock(qd, force, &ip->i_res->rs_qa_qd_ghs[x]);
952	if (error)	952	if (error)
953	break;	953	break;
954	}	954	}
955		955
956	if (!error)	956	if (!error)
957	set_bit(GIF_QD_LOCKED, &ip->i_flags);	957	set_bit(GIF_QD_LOCKED, &ip->i_flags);
958	else {	958	else {
959	while (x--)	959	while (x--)
960	gfs2_glock_dq_uninit(&ip->i_res->rs_qa_qd_ghs[x]);	960	gfs2_glock_dq_uninit(&ip->i_res->rs_qa_qd_ghs[x]);
961	gfs2_quota_unhold(ip);	961	gfs2_quota_unhold(ip);
962	}	962	}
963		963
964	return error;	964	return error;
965	}	965	}
966		966
967	static int need_sync(struct gfs2_quota_data *qd)	967	static int need_sync(struct gfs2_quota_data *qd)
968	{	968	{
969	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;	969	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
970	struct gfs2_tune *gt = &sdp->sd_tune;	970	struct gfs2_tune *gt = &sdp->sd_tune;
971	s64 value;	971	s64 value;
972	unsigned int num, den;	972	unsigned int num, den;
973	int do_sync = 1;	973	int do_sync = 1;
974		974
975	if (!qd->qd_qb.qb_limit)	975	if (!qd->qd_qb.qb_limit)
976	return 0;	976	return 0;
977		977
978	spin_lock(&qd_lru_lock);	978	spin_lock(&qd_lru_lock);
979	value = qd->qd_change;	979	value = qd->qd_change;
980	spin_unlock(&qd_lru_lock);	980	spin_unlock(&qd_lru_lock);
981		981
982	spin_lock(&gt->gt_spin);	982	spin_lock(&gt->gt_spin);
983	num = gt->gt_quota_scale_num;	983	num = gt->gt_quota_scale_num;
984	den = gt->gt_quota_scale_den;	984	den = gt->gt_quota_scale_den;
985	spin_unlock(&gt->gt_spin);	985	spin_unlock(&gt->gt_spin);
986		986
987	if (value < 0)	987	if (value < 0)
988	do_sync = 0;	988	do_sync = 0;
989	else if ((s64)be64_to_cpu(qd->qd_qb.qb_value) >=	989	else if ((s64)be64_to_cpu(qd->qd_qb.qb_value) >=
990	(s64)be64_to_cpu(qd->qd_qb.qb_limit))	990	(s64)be64_to_cpu(qd->qd_qb.qb_limit))
991	do_sync = 0;	991	do_sync = 0;
992	else {	992	else {
993	value = gfs2_jindex_size(sdp) num;	993	value = gfs2_jindex_size(sdp) num;
994	value = div_s64(value, den);	994	value = div_s64(value, den);
995	value += (s64)be64_to_cpu(qd->qd_qb.qb_value);	995	value += (s64)be64_to_cpu(qd->qd_qb.qb_value);
996	if (value < (s64)be64_to_cpu(qd->qd_qb.qb_limit))	996	if (value < (s64)be64_to_cpu(qd->qd_qb.qb_limit))
997	do_sync = 0;	997	do_sync = 0;
998	}	998	}
999		999
1000	return do_sync;	1000	return do_sync;
1001	}	1001	}
1002		1002
1003	void gfs2_quota_unlock(struct gfs2_inode *ip)	1003	void gfs2_quota_unlock(struct gfs2_inode *ip)
1004	{	1004	{
1005	struct gfs2_quota_data *qda[4];	1005	struct gfs2_quota_data *qda[4];
1006	unsigned int count = 0;	1006	unsigned int count = 0;
1007	unsigned int x;	1007	unsigned int x;
1008		1008
1009	if (!test_and_clear_bit(GIF_QD_LOCKED, &ip->i_flags))	1009	if (!test_and_clear_bit(GIF_QD_LOCKED, &ip->i_flags))
1010	goto out;	1010	goto out;
1011		1011
1012	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {	1012	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
1013	struct gfs2_quota_data *qd;	1013	struct gfs2_quota_data *qd;
1014	int sync;	1014	int sync;
1015		1015
1016	qd = ip->i_res->rs_qa_qd[x];	1016	qd = ip->i_res->rs_qa_qd[x];
1017	sync = need_sync(qd);	1017	sync = need_sync(qd);
1018		1018
1019	gfs2_glock_dq_uninit(&ip->i_res->rs_qa_qd_ghs[x]);	1019	gfs2_glock_dq_uninit(&ip->i_res->rs_qa_qd_ghs[x]);
1020		1020
1021	if (sync && qd_trylock(qd))	1021	if (sync && qd_trylock(qd))
1022	qda[count++] = qd;	1022	qda[count++] = qd;
1023	}	1023	}
1024		1024
1025	if (count) {	1025	if (count) {
1026	do_sync(count, qda);	1026	do_sync(count, qda);
1027	for (x = 0; x < count; x++)	1027	for (x = 0; x < count; x++)
1028	qd_unlock(qda[x]);	1028	qd_unlock(qda[x]);
1029	}	1029	}
1030		1030
1031	out:	1031	out:
1032	gfs2_quota_unhold(ip);	1032	gfs2_quota_unhold(ip);
1033	}	1033	}
1034		1034
1035	#define MAX_LINE 256	1035	#define MAX_LINE 256
1036		1036
1037	static int print_message(struct gfs2_quota_data qd, char type)	1037	static int print_message(struct gfs2_quota_data qd, char type)
1038	{	1038	{
1039	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;	1039	struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
1040		1040
1041	printk(KERN_INFO "GFS2: fsid=%s: quota %s for %s %u\n",	1041	printk(KERN_INFO "GFS2: fsid=%s: quota %s for %s %u\n",
1042	sdp->sd_fsname, type,	1042	sdp->sd_fsname, type,
1043	(test_bit(QDF_USER, &qd->qd_flags)) ? "user" : "group",	1043	(test_bit(QDF_USER, &qd->qd_flags)) ? "user" : "group",
1044	qd->qd_id);	1044	qd->qd_id);
1045		1045
1046	return 0;	1046	return 0;
1047	}	1047	}
1048		1048
1049	int gfs2_quota_check(struct gfs2_inode *ip, u32 uid, u32 gid)	1049	int gfs2_quota_check(struct gfs2_inode *ip, u32 uid, u32 gid)
1050	{	1050	{
1051	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1051	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1052	struct gfs2_quota_data *qd;	1052	struct gfs2_quota_data *qd;
1053	s64 value;	1053	s64 value;
1054	unsigned int x;	1054	unsigned int x;
1055	int error = 0;	1055	int error = 0;
1056		1056
1057	if (!test_bit(GIF_QD_LOCKED, &ip->i_flags))	1057	if (!test_bit(GIF_QD_LOCKED, &ip->i_flags))
1058	return 0;	1058	return 0;
1059		1059
1060	if (sdp->sd_args.ar_quota != GFS2_QUOTA_ON)	1060	if (sdp->sd_args.ar_quota != GFS2_QUOTA_ON)
1061	return 0;	1061	return 0;
1062		1062
1063	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {	1063	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
1064	qd = ip->i_res->rs_qa_qd[x];	1064	qd = ip->i_res->rs_qa_qd[x];
1065		1065
1066	if (!((qd->qd_id == uid && test_bit(QDF_USER, &qd->qd_flags)) \|\|	1066	if (!((qd->qd_id == uid && test_bit(QDF_USER, &qd->qd_flags)) \|\|
1067	(qd->qd_id == gid && !test_bit(QDF_USER, &qd->qd_flags))))	1067	(qd->qd_id == gid && !test_bit(QDF_USER, &qd->qd_flags))))
1068	continue;	1068	continue;
1069		1069
1070	value = (s64)be64_to_cpu(qd->qd_qb.qb_value);	1070	value = (s64)be64_to_cpu(qd->qd_qb.qb_value);
1071	spin_lock(&qd_lru_lock);	1071	spin_lock(&qd_lru_lock);
1072	value += qd->qd_change;	1072	value += qd->qd_change;
1073	spin_unlock(&qd_lru_lock);	1073	spin_unlock(&qd_lru_lock);
1074		1074
1075	if (be64_to_cpu(qd->qd_qb.qb_limit) && (s64)be64_to_cpu(qd->qd_qb.qb_limit) < value) {	1075	if (be64_to_cpu(qd->qd_qb.qb_limit) && (s64)be64_to_cpu(qd->qd_qb.qb_limit) < value) {
1076	print_message(qd, "exceeded");	1076	print_message(qd, "exceeded");
1077	quota_send_warning(make_kqid(&init_user_ns,	1077	quota_send_warning(make_kqid(&init_user_ns,
1078	test_bit(QDF_USER, &qd->qd_flags) ?	1078	test_bit(QDF_USER, &qd->qd_flags) ?
1079	USRQUOTA : GRPQUOTA,	1079	USRQUOTA : GRPQUOTA,
1080	qd->qd_id),	1080	qd->qd_id),
1081	sdp->sd_vfs->s_dev, QUOTA_NL_BHARDWARN);	1081	sdp->sd_vfs->s_dev, QUOTA_NL_BHARDWARN);
1082		1082
1083	error = -EDQUOT;	1083	error = -EDQUOT;
1084	break;	1084	break;
1085	} else if (be64_to_cpu(qd->qd_qb.qb_warn) &&	1085	} else if (be64_to_cpu(qd->qd_qb.qb_warn) &&
1086	(s64)be64_to_cpu(qd->qd_qb.qb_warn) < value &&	1086	(s64)be64_to_cpu(qd->qd_qb.qb_warn) < value &&
1087	time_after_eq(jiffies, qd->qd_last_warn +	1087	time_after_eq(jiffies, qd->qd_last_warn +
1088	gfs2_tune_get(sdp,	1088	gfs2_tune_get(sdp,
1089	gt_quota_warn_period) * HZ)) {	1089	gt_quota_warn_period) * HZ)) {
1090	quota_send_warning(make_kqid(&init_user_ns,	1090	quota_send_warning(make_kqid(&init_user_ns,
1091	test_bit(QDF_USER, &qd->qd_flags) ?	1091	test_bit(QDF_USER, &qd->qd_flags) ?
1092	USRQUOTA : GRPQUOTA,	1092	USRQUOTA : GRPQUOTA,
1093	qd->qd_id),	1093	qd->qd_id),
1094	sdp->sd_vfs->s_dev, QUOTA_NL_BSOFTWARN);	1094	sdp->sd_vfs->s_dev, QUOTA_NL_BSOFTWARN);
1095	error = print_message(qd, "warning");	1095	error = print_message(qd, "warning");
1096	qd->qd_last_warn = jiffies;	1096	qd->qd_last_warn = jiffies;
1097	}	1097	}
1098	}	1098	}
1099		1099
1100	return error;	1100	return error;
1101	}	1101	}
1102		1102
1103	void gfs2_quota_change(struct gfs2_inode *ip, s64 change,	1103	void gfs2_quota_change(struct gfs2_inode *ip, s64 change,
1104	u32 uid, u32 gid)	1104	u32 uid, u32 gid)
1105	{	1105	{
1106	struct gfs2_quota_data *qd;	1106	struct gfs2_quota_data *qd;
1107	unsigned int x;	1107	unsigned int x;
1108		1108
1109	if (gfs2_assert_warn(GFS2_SB(&ip->i_inode), change))	1109	if (gfs2_assert_warn(GFS2_SB(&ip->i_inode), change))
1110	return;	1110	return;
1111	if (ip->i_diskflags & GFS2_DIF_SYSTEM)	1111	if (ip->i_diskflags & GFS2_DIF_SYSTEM)
1112	return;	1112	return;
1113		1113
1114	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {	1114	for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
1115	qd = ip->i_res->rs_qa_qd[x];	1115	qd = ip->i_res->rs_qa_qd[x];
1116		1116
1117	if ((qd->qd_id == uid && test_bit(QDF_USER, &qd->qd_flags)) \|\|	1117	if ((qd->qd_id == uid && test_bit(QDF_USER, &qd->qd_flags)) \|\|
1118	(qd->qd_id == gid && !test_bit(QDF_USER, &qd->qd_flags))) {	1118	(qd->qd_id == gid && !test_bit(QDF_USER, &qd->qd_flags))) {
1119	do_qc(qd, change);	1119	do_qc(qd, change);
1120	}	1120	}
1121	}	1121	}
1122	}	1122	}
1123		1123
1124	int gfs2_quota_sync(struct super_block *sb, int type)	1124	int gfs2_quota_sync(struct super_block *sb, int type)
1125	{	1125	{
1126	struct gfs2_sbd *sdp = sb->s_fs_info;	1126	struct gfs2_sbd *sdp = sb->s_fs_info;
1127	struct gfs2_quota_data **qda;	1127	struct gfs2_quota_data **qda;
1128	unsigned int max_qd = gfs2_tune_get(sdp, gt_quota_simul_sync);	1128	unsigned int max_qd = gfs2_tune_get(sdp, gt_quota_simul_sync);
1129	unsigned int num_qd;	1129	unsigned int num_qd;
1130	unsigned int x;	1130	unsigned int x;
1131	int error = 0;	1131	int error = 0;
1132		1132
1133	sdp->sd_quota_sync_gen++;	1133	sdp->sd_quota_sync_gen++;
1134		1134
1135	qda = kcalloc(max_qd, sizeof(struct gfs2_quota_data *), GFP_KERNEL);	1135	qda = kcalloc(max_qd, sizeof(struct gfs2_quota_data *), GFP_KERNEL);
1136	if (!qda)	1136	if (!qda)
1137	return -ENOMEM;	1137	return -ENOMEM;
1138		1138
1139	do {	1139	do {
1140	num_qd = 0;	1140	num_qd = 0;
1141		1141
1142	for (;;) {	1142	for (;;) {
1143	error = qd_fish(sdp, qda + num_qd);	1143	error = qd_fish(sdp, qda + num_qd);
1144	if (error \|\| !qda[num_qd])	1144	if (error \|\| !qda[num_qd])
1145	break;	1145	break;
1146	if (++num_qd == max_qd)	1146	if (++num_qd == max_qd)
1147	break;	1147	break;
1148	}	1148	}
1149		1149
1150	if (num_qd) {	1150	if (num_qd) {
1151	if (!error)	1151	if (!error)
1152	error = do_sync(num_qd, qda);	1152	error = do_sync(num_qd, qda);
1153	if (!error)	1153	if (!error)
1154	for (x = 0; x < num_qd; x++)	1154	for (x = 0; x < num_qd; x++)
1155	qda[x]->qd_sync_gen =	1155	qda[x]->qd_sync_gen =
1156	sdp->sd_quota_sync_gen;	1156	sdp->sd_quota_sync_gen;
1157		1157
1158	for (x = 0; x < num_qd; x++)	1158	for (x = 0; x < num_qd; x++)
1159	qd_unlock(qda[x]);	1159	qd_unlock(qda[x]);
1160	}	1160	}
1161	} while (!error && num_qd == max_qd);	1161	} while (!error && num_qd == max_qd);
1162		1162
1163	kfree(qda);	1163	kfree(qda);
1164		1164
1165	return error;	1165	return error;
1166	}	1166	}
1167		1167
1168	static int gfs2_quota_sync_timeo(struct super_block *sb, int type)	1168	static int gfs2_quota_sync_timeo(struct super_block *sb, int type)
1169	{	1169	{
1170	return gfs2_quota_sync(sb, type);	1170	return gfs2_quota_sync(sb, type);
1171	}	1171	}
1172		1172
1173	int gfs2_quota_refresh(struct gfs2_sbd *sdp, int user, u32 id)	1173	int gfs2_quota_refresh(struct gfs2_sbd *sdp, int user, u32 id)
1174	{	1174	{
1175	struct gfs2_quota_data *qd;	1175	struct gfs2_quota_data *qd;
1176	struct gfs2_holder q_gh;	1176	struct gfs2_holder q_gh;
1177	int error;	1177	int error;
1178		1178
1179	error = qd_get(sdp, user, id, &qd);	1179	error = qd_get(sdp, user, id, &qd);
1180	if (error)	1180	if (error)
1181	return error;	1181	return error;
1182		1182
1183	error = do_glock(qd, FORCE, &q_gh);	1183	error = do_glock(qd, FORCE, &q_gh);
1184	if (!error)	1184	if (!error)
1185	gfs2_glock_dq_uninit(&q_gh);	1185	gfs2_glock_dq_uninit(&q_gh);
1186		1186
1187	qd_put(qd);	1187	qd_put(qd);
1188	return error;	1188	return error;
1189	}	1189	}
1190		1190
1191	static void gfs2_quota_change_in(struct gfs2_quota_change_host qc, const void buf)	1191	static void gfs2_quota_change_in(struct gfs2_quota_change_host qc, const void buf)
1192	{	1192	{
1193	const struct gfs2_quota_change *str = buf;	1193	const struct gfs2_quota_change *str = buf;
1194		1194
1195	qc->qc_change = be64_to_cpu(str->qc_change);	1195	qc->qc_change = be64_to_cpu(str->qc_change);
1196	qc->qc_flags = be32_to_cpu(str->qc_flags);	1196	qc->qc_flags = be32_to_cpu(str->qc_flags);
1197	qc->qc_id = be32_to_cpu(str->qc_id);	1197	qc->qc_id = be32_to_cpu(str->qc_id);
1198	}	1198	}
1199		1199
1200	int gfs2_quota_init(struct gfs2_sbd *sdp)	1200	int gfs2_quota_init(struct gfs2_sbd *sdp)
1201	{	1201	{
1202	struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);	1202	struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
1203	u64 size = i_size_read(sdp->sd_qc_inode);	1203	u64 size = i_size_read(sdp->sd_qc_inode);
1204	unsigned int blocks = size >> sdp->sd_sb.sb_bsize_shift;	1204	unsigned int blocks = size >> sdp->sd_sb.sb_bsize_shift;
1205	unsigned int x, slot = 0;	1205	unsigned int x, slot = 0;
1206	unsigned int found = 0;	1206	unsigned int found = 0;
1207	u64 dblock;	1207	u64 dblock;
1208	u32 extlen = 0;	1208	u32 extlen = 0;
1209	int error;	1209	int error;
1210		1210
1211	if (gfs2_check_internal_file_size(sdp->sd_qc_inode, 1, 64 << 20))	1211	if (gfs2_check_internal_file_size(sdp->sd_qc_inode, 1, 64 << 20))
1212	return -EIO;	1212	return -EIO;
1213		1213
1214	sdp->sd_quota_slots = blocks * sdp->sd_qc_per_block;	1214	sdp->sd_quota_slots = blocks * sdp->sd_qc_per_block;
1215	sdp->sd_quota_chunks = DIV_ROUND_UP(sdp->sd_quota_slots, 8 * PAGE_SIZE);	1215	sdp->sd_quota_chunks = DIV_ROUND_UP(sdp->sd_quota_slots, 8 * PAGE_SIZE);
1216		1216
1217	error = -ENOMEM;	1217	error = -ENOMEM;
1218		1218
1219	sdp->sd_quota_bitmap = kcalloc(sdp->sd_quota_chunks,	1219	sdp->sd_quota_bitmap = kcalloc(sdp->sd_quota_chunks,
1220	sizeof(unsigned char *), GFP_NOFS);	1220	sizeof(unsigned char *), GFP_NOFS);
1221	if (!sdp->sd_quota_bitmap)	1221	if (!sdp->sd_quota_bitmap)
1222	return error;	1222	return error;
1223		1223
1224	for (x = 0; x < sdp->sd_quota_chunks; x++) {	1224	for (x = 0; x < sdp->sd_quota_chunks; x++) {
1225	sdp->sd_quota_bitmap[x] = kzalloc(PAGE_SIZE, GFP_NOFS);	1225	sdp->sd_quota_bitmap[x] = kzalloc(PAGE_SIZE, GFP_NOFS);
1226	if (!sdp->sd_quota_bitmap[x])	1226	if (!sdp->sd_quota_bitmap[x])
1227	goto fail;	1227	goto fail;
1228	}	1228	}
1229		1229
1230	for (x = 0; x < blocks; x++) {	1230	for (x = 0; x < blocks; x++) {
1231	struct buffer_head *bh;	1231	struct buffer_head *bh;
1232	unsigned int y;	1232	unsigned int y;
1233		1233
1234	if (!extlen) {	1234	if (!extlen) {
1235	int new = 0;	1235	int new = 0;
1236	error = gfs2_extent_map(&ip->i_inode, x, &new, &dblock, &extlen);	1236	error = gfs2_extent_map(&ip->i_inode, x, &new, &dblock, &extlen);
1237	if (error)	1237	if (error)
1238	goto fail;	1238	goto fail;
1239	}	1239	}
1240	error = -EIO;	1240	error = -EIO;
1241	bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);	1241	bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
1242	if (!bh)	1242	if (!bh)
1243	goto fail;	1243	goto fail;
1244	if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC)) {	1244	if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC)) {
1245	brelse(bh);	1245	brelse(bh);
1246	goto fail;	1246	goto fail;
1247	}	1247	}
1248		1248
1249	for (y = 0; y < sdp->sd_qc_per_block && slot < sdp->sd_quota_slots;	1249	for (y = 0; y < sdp->sd_qc_per_block && slot < sdp->sd_quota_slots;
1250	y++, slot++) {	1250	y++, slot++) {
1251	struct gfs2_quota_change_host qc;	1251	struct gfs2_quota_change_host qc;
1252	struct gfs2_quota_data *qd;	1252	struct gfs2_quota_data *qd;
1253		1253
1254	gfs2_quota_change_in(&qc, bh->b_data +	1254	gfs2_quota_change_in(&qc, bh->b_data +
1255	sizeof(struct gfs2_meta_header) +	1255	sizeof(struct gfs2_meta_header) +
1256	y * sizeof(struct gfs2_quota_change));	1256	y * sizeof(struct gfs2_quota_change));
1257	if (!qc.qc_change)	1257	if (!qc.qc_change)
1258	continue;	1258	continue;
1259		1259
1260	error = qd_alloc(sdp, (qc.qc_flags & GFS2_QCF_USER),	1260	error = qd_alloc(sdp, (qc.qc_flags & GFS2_QCF_USER),
1261	qc.qc_id, &qd);	1261	qc.qc_id, &qd);
1262	if (error) {	1262	if (error) {
1263	brelse(bh);	1263	brelse(bh);
1264	goto fail;	1264	goto fail;
1265	}	1265	}
1266		1266
1267	set_bit(QDF_CHANGE, &qd->qd_flags);	1267	set_bit(QDF_CHANGE, &qd->qd_flags);
1268	qd->qd_change = qc.qc_change;	1268	qd->qd_change = qc.qc_change;
1269	qd->qd_slot = slot;	1269	qd->qd_slot = slot;
1270	qd->qd_slot_count = 1;	1270	qd->qd_slot_count = 1;
1271		1271
1272	spin_lock(&qd_lru_lock);	1272	spin_lock(&qd_lru_lock);
1273	gfs2_icbit_munge(sdp, sdp->sd_quota_bitmap, slot, 1);	1273	gfs2_icbit_munge(sdp, sdp->sd_quota_bitmap, slot, 1);
1274	list_add(&qd->qd_list, &sdp->sd_quota_list);	1274	list_add(&qd->qd_list, &sdp->sd_quota_list);
1275	atomic_inc(&sdp->sd_quota_count);	1275	atomic_inc(&sdp->sd_quota_count);
1276	spin_unlock(&qd_lru_lock);	1276	spin_unlock(&qd_lru_lock);
1277		1277
1278	found++;	1278	found++;
1279	}	1279	}
1280		1280
1281	brelse(bh);	1281	brelse(bh);
1282	dblock++;	1282	dblock++;
1283	extlen--;	1283	extlen--;
1284	}	1284	}
1285		1285
1286	if (found)	1286	if (found)
1287	fs_info(sdp, "found %u quota changes\n", found);	1287	fs_info(sdp, "found %u quota changes\n", found);
1288		1288
1289	return 0;	1289	return 0;
1290		1290
1291	fail:	1291	fail:
1292	gfs2_quota_cleanup(sdp);	1292	gfs2_quota_cleanup(sdp);
1293	return error;	1293	return error;
1294	}	1294	}
1295		1295
1296	void gfs2_quota_cleanup(struct gfs2_sbd *sdp)	1296	void gfs2_quota_cleanup(struct gfs2_sbd *sdp)
1297	{	1297	{
1298	struct list_head *head = &sdp->sd_quota_list;	1298	struct list_head *head = &sdp->sd_quota_list;
1299	struct gfs2_quota_data *qd;	1299	struct gfs2_quota_data *qd;
1300	unsigned int x;	1300	unsigned int x;
1301		1301
1302	spin_lock(&qd_lru_lock);	1302	spin_lock(&qd_lru_lock);
1303	while (!list_empty(head)) {	1303	while (!list_empty(head)) {
1304	qd = list_entry(head->prev, struct gfs2_quota_data, qd_list);	1304	qd = list_entry(head->prev, struct gfs2_quota_data, qd_list);
1305		1305
1306	if (atomic_read(&qd->qd_count) > 1 \|\|	1306	if (atomic_read(&qd->qd_count) > 1 \|\|
1307	(atomic_read(&qd->qd_count) &&	1307	(atomic_read(&qd->qd_count) &&
1308	!test_bit(QDF_CHANGE, &qd->qd_flags))) {	1308	!test_bit(QDF_CHANGE, &qd->qd_flags))) {
1309	list_move(&qd->qd_list, head);	1309	list_move(&qd->qd_list, head);
1310	spin_unlock(&qd_lru_lock);	1310	spin_unlock(&qd_lru_lock);
1311	schedule();	1311	schedule();
1312	spin_lock(&qd_lru_lock);	1312	spin_lock(&qd_lru_lock);
1313	continue;	1313	continue;
1314	}	1314	}
1315		1315
1316	list_del(&qd->qd_list);	1316	list_del(&qd->qd_list);
1317	/* Also remove if this qd exists in the reclaim list */	1317	/* Also remove if this qd exists in the reclaim list */
1318	if (!list_empty(&qd->qd_reclaim)) {	1318	if (!list_empty(&qd->qd_reclaim)) {
1319	list_del_init(&qd->qd_reclaim);	1319	list_del_init(&qd->qd_reclaim);
1320	atomic_dec(&qd_lru_count);	1320	atomic_dec(&qd_lru_count);
1321	}	1321	}
1322	atomic_dec(&sdp->sd_quota_count);	1322	atomic_dec(&sdp->sd_quota_count);
1323	spin_unlock(&qd_lru_lock);	1323	spin_unlock(&qd_lru_lock);
1324		1324
1325	if (!atomic_read(&qd->qd_count)) {	1325	if (!atomic_read(&qd->qd_count)) {
1326	gfs2_assert_warn(sdp, !qd->qd_change);	1326	gfs2_assert_warn(sdp, !qd->qd_change);
1327	gfs2_assert_warn(sdp, !qd->qd_slot_count);	1327	gfs2_assert_warn(sdp, !qd->qd_slot_count);
1328	} else	1328	} else
1329	gfs2_assert_warn(sdp, qd->qd_slot_count == 1);	1329	gfs2_assert_warn(sdp, qd->qd_slot_count == 1);
1330	gfs2_assert_warn(sdp, !qd->qd_bh_count);	1330	gfs2_assert_warn(sdp, !qd->qd_bh_count);
1331		1331
1332	gfs2_glock_put(qd->qd_gl);	1332	gfs2_glock_put(qd->qd_gl);
1333	kmem_cache_free(gfs2_quotad_cachep, qd);	1333	kmem_cache_free(gfs2_quotad_cachep, qd);
1334		1334
1335	spin_lock(&qd_lru_lock);	1335	spin_lock(&qd_lru_lock);
1336	}	1336	}
1337	spin_unlock(&qd_lru_lock);	1337	spin_unlock(&qd_lru_lock);
1338		1338
1339	gfs2_assert_warn(sdp, !atomic_read(&sdp->sd_quota_count));	1339	gfs2_assert_warn(sdp, !atomic_read(&sdp->sd_quota_count));
1340		1340
1341	if (sdp->sd_quota_bitmap) {	1341	if (sdp->sd_quota_bitmap) {
1342	for (x = 0; x < sdp->sd_quota_chunks; x++)	1342	for (x = 0; x < sdp->sd_quota_chunks; x++)
1343	kfree(sdp->sd_quota_bitmap[x]);	1343	kfree(sdp->sd_quota_bitmap[x]);
1344	kfree(sdp->sd_quota_bitmap);	1344	kfree(sdp->sd_quota_bitmap);
1345	}	1345	}
1346	}	1346	}
1347		1347
1348	static void quotad_error(struct gfs2_sbd sdp, const char msg, int error)	1348	static void quotad_error(struct gfs2_sbd sdp, const char msg, int error)
1349	{	1349	{
1350	if (error == 0 \|\| error == -EROFS)	1350	if (error == 0 \|\| error == -EROFS)
1351	return;	1351	return;
1352	if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))	1352	if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
1353	fs_err(sdp, "gfs2_quotad: %s error %d\n", msg, error);	1353	fs_err(sdp, "gfs2_quotad: %s error %d\n", msg, error);
1354	}	1354	}
1355		1355
1356	static void quotad_check_timeo(struct gfs2_sbd sdp, const char msg,	1356	static void quotad_check_timeo(struct gfs2_sbd sdp, const char msg,
1357	int (fxn)(struct super_block sb, int type),	1357	int (fxn)(struct super_block sb, int type),
1358	unsigned long t, unsigned long *timeo,	1358	unsigned long t, unsigned long *timeo,
1359	unsigned int *new_timeo)	1359	unsigned int *new_timeo)
1360	{	1360	{
1361	if (t >= *timeo) {	1361	if (t >= *timeo) {
1362	int error = fxn(sdp->sd_vfs, 0);	1362	int error = fxn(sdp->sd_vfs, 0);
1363	quotad_error(sdp, msg, error);	1363	quotad_error(sdp, msg, error);
1364	timeo = gfs2_tune_get_i(&sdp->sd_tune, new_timeo) HZ;	1364	timeo = gfs2_tune_get_i(&sdp->sd_tune, new_timeo) HZ;
1365	} else {	1365	} else {
1366	*timeo -= t;	1366	*timeo -= t;
1367	}	1367	}
1368	}	1368	}
1369		1369
1370	static void quotad_check_trunc_list(struct gfs2_sbd *sdp)	1370	static void quotad_check_trunc_list(struct gfs2_sbd *sdp)
1371	{	1371	{
1372	struct gfs2_inode *ip;	1372	struct gfs2_inode *ip;
1373		1373
1374	while(1) {	1374	while(1) {
1375	ip = NULL;	1375	ip = NULL;
1376	spin_lock(&sdp->sd_trunc_lock);	1376	spin_lock(&sdp->sd_trunc_lock);
1377	if (!list_empty(&sdp->sd_trunc_list)) {	1377	if (!list_empty(&sdp->sd_trunc_list)) {
1378	ip = list_entry(sdp->sd_trunc_list.next,	1378	ip = list_entry(sdp->sd_trunc_list.next,
1379	struct gfs2_inode, i_trunc_list);	1379	struct gfs2_inode, i_trunc_list);
1380	list_del_init(&ip->i_trunc_list);	1380	list_del_init(&ip->i_trunc_list);
1381	}	1381	}
1382	spin_unlock(&sdp->sd_trunc_lock);	1382	spin_unlock(&sdp->sd_trunc_lock);
1383	if (ip == NULL)	1383	if (ip == NULL)
1384	return;	1384	return;
1385	gfs2_glock_finish_truncate(ip);	1385	gfs2_glock_finish_truncate(ip);
1386	}	1386	}
1387	}	1387	}
1388		1388
1389	void gfs2_wake_up_statfs(struct gfs2_sbd *sdp) {	1389	void gfs2_wake_up_statfs(struct gfs2_sbd *sdp) {
1390	if (!sdp->sd_statfs_force_sync) {	1390	if (!sdp->sd_statfs_force_sync) {
1391	sdp->sd_statfs_force_sync = 1;	1391	sdp->sd_statfs_force_sync = 1;
1392	wake_up(&sdp->sd_quota_wait);	1392	wake_up(&sdp->sd_quota_wait);
1393	}	1393	}
1394	}	1394	}
1395		1395
1396		1396
1397	/**	1397	/**
1398	* gfs2_quotad - Write cached quota changes into the quota file	1398	* gfs2_quotad - Write cached quota changes into the quota file
1399	* @sdp: Pointer to GFS2 superblock	1399	* @sdp: Pointer to GFS2 superblock
1400	*	1400	*
1401	*/	1401	*/
1402		1402
1403	int gfs2_quotad(void *data)	1403	int gfs2_quotad(void *data)
1404	{	1404	{
1405	struct gfs2_sbd *sdp = data;	1405	struct gfs2_sbd *sdp = data;
1406	struct gfs2_tune *tune = &sdp->sd_tune;	1406	struct gfs2_tune *tune = &sdp->sd_tune;
1407	unsigned long statfs_timeo = 0;	1407	unsigned long statfs_timeo = 0;
1408	unsigned long quotad_timeo = 0;	1408	unsigned long quotad_timeo = 0;
1409	unsigned long t = 0;	1409	unsigned long t = 0;
1410	DEFINE_WAIT(wait);	1410	DEFINE_WAIT(wait);
1411	int empty;	1411	int empty;
1412		1412
1413	while (!kthread_should_stop()) {	1413	while (!kthread_should_stop()) {
1414		1414
1415	/* Update the master statfs file */	1415	/* Update the master statfs file */
1416	if (sdp->sd_statfs_force_sync) {	1416	if (sdp->sd_statfs_force_sync) {
1417	int error = gfs2_statfs_sync(sdp->sd_vfs, 0);	1417	int error = gfs2_statfs_sync(sdp->sd_vfs, 0);
1418	quotad_error(sdp, "statfs", error);	1418	quotad_error(sdp, "statfs", error);
1419	statfs_timeo = gfs2_tune_get(sdp, gt_statfs_quantum) * HZ;	1419	statfs_timeo = gfs2_tune_get(sdp, gt_statfs_quantum) * HZ;
1420	}	1420	}
1421	else	1421	else
1422	quotad_check_timeo(sdp, "statfs", gfs2_statfs_sync, t,	1422	quotad_check_timeo(sdp, "statfs", gfs2_statfs_sync, t,
1423	&statfs_timeo,	1423	&statfs_timeo,
1424	&tune->gt_statfs_quantum);	1424	&tune->gt_statfs_quantum);
1425		1425
1426	/* Update quota file */	1426	/* Update quota file */
1427	quotad_check_timeo(sdp, "sync", gfs2_quota_sync_timeo, t,	1427	quotad_check_timeo(sdp, "sync", gfs2_quota_sync_timeo, t,
1428	&quotad_timeo, &tune->gt_quota_quantum);	1428	&quotad_timeo, &tune->gt_quota_quantum);
1429		1429
1430	/* Check for & recover partially truncated inodes */	1430	/* Check for & recover partially truncated inodes */
1431	quotad_check_trunc_list(sdp);	1431	quotad_check_trunc_list(sdp);
1432		1432
1433	try_to_freeze();	1433	try_to_freeze();
1434		1434
1435	t = min(quotad_timeo, statfs_timeo);	1435	t = min(quotad_timeo, statfs_timeo);
1436		1436
1437	prepare_to_wait(&sdp->sd_quota_wait, &wait, TASK_INTERRUPTIBLE);	1437	prepare_to_wait(&sdp->sd_quota_wait, &wait, TASK_INTERRUPTIBLE);
1438	spin_lock(&sdp->sd_trunc_lock);	1438	spin_lock(&sdp->sd_trunc_lock);
1439	empty = list_empty(&sdp->sd_trunc_list);	1439	empty = list_empty(&sdp->sd_trunc_list);
1440	spin_unlock(&sdp->sd_trunc_lock);	1440	spin_unlock(&sdp->sd_trunc_lock);
1441	if (empty && !sdp->sd_statfs_force_sync)	1441	if (empty && !sdp->sd_statfs_force_sync)
1442	t -= schedule_timeout(t);	1442	t -= schedule_timeout(t);
1443	else	1443	else
1444	t = 0;	1444	t = 0;
1445	finish_wait(&sdp->sd_quota_wait, &wait);	1445	finish_wait(&sdp->sd_quota_wait, &wait);
1446	}	1446	}
1447		1447
1448	return 0;	1448	return 0;
1449	}	1449	}
1450		1450
1451	static int gfs2_quota_get_xstate(struct super_block *sb,	1451	static int gfs2_quota_get_xstate(struct super_block *sb,
1452	struct fs_quota_stat *fqs)	1452	struct fs_quota_stat *fqs)
1453	{	1453	{
1454	struct gfs2_sbd *sdp = sb->s_fs_info;	1454	struct gfs2_sbd *sdp = sb->s_fs_info;
1455		1455
1456	memset(fqs, 0, sizeof(struct fs_quota_stat));	1456	memset(fqs, 0, sizeof(struct fs_quota_stat));
1457	fqs->qs_version = FS_QSTAT_VERSION;	1457	fqs->qs_version = FS_QSTAT_VERSION;
1458		1458
1459	switch (sdp->sd_args.ar_quota) {	1459	switch (sdp->sd_args.ar_quota) {
1460	case GFS2_QUOTA_ON:	1460	case GFS2_QUOTA_ON:
1461	fqs->qs_flags \|= (FS_QUOTA_UDQ_ENFD \| FS_QUOTA_GDQ_ENFD);	1461	fqs->qs_flags \|= (FS_QUOTA_UDQ_ENFD \| FS_QUOTA_GDQ_ENFD);
1462	/FALLTHRU/	1462	/FALLTHRU/
1463	case GFS2_QUOTA_ACCOUNT:	1463	case GFS2_QUOTA_ACCOUNT:
1464	fqs->qs_flags \|= (FS_QUOTA_UDQ_ACCT \| FS_QUOTA_GDQ_ACCT);	1464	fqs->qs_flags \|= (FS_QUOTA_UDQ_ACCT \| FS_QUOTA_GDQ_ACCT);
1465	break;	1465	break;
1466	case GFS2_QUOTA_OFF:	1466	case GFS2_QUOTA_OFF:
1467	break;	1467	break;
1468	}	1468	}
1469		1469
1470	if (sdp->sd_quota_inode) {	1470	if (sdp->sd_quota_inode) {
1471	fqs->qs_uquota.qfs_ino = GFS2_I(sdp->sd_quota_inode)->i_no_addr;	1471	fqs->qs_uquota.qfs_ino = GFS2_I(sdp->sd_quota_inode)->i_no_addr;
1472	fqs->qs_uquota.qfs_nblks = sdp->sd_quota_inode->i_blocks;	1472	fqs->qs_uquota.qfs_nblks = sdp->sd_quota_inode->i_blocks;
1473	}	1473	}
1474	fqs->qs_uquota.qfs_nextents = 1; /* unsupported */	1474	fqs->qs_uquota.qfs_nextents = 1; /* unsupported */
1475	fqs->qs_gquota = fqs->qs_uquota; /* its the same inode in both cases */	1475	fqs->qs_gquota = fqs->qs_uquota; /* its the same inode in both cases */
1476	fqs->qs_incoredqs = atomic_read(&qd_lru_count);	1476	fqs->qs_incoredqs = atomic_read(&qd_lru_count);
1477	return 0;	1477	return 0;
1478	}	1478	}
1479		1479
1480	static int gfs2_get_dqblk(struct super_block *sb, struct kqid qid,	1480	static int gfs2_get_dqblk(struct super_block *sb, struct kqid qid,
1481	struct fs_disk_quota *fdq)	1481	struct fs_disk_quota *fdq)
1482	{	1482	{
1483	struct gfs2_sbd *sdp = sb->s_fs_info;	1483	struct gfs2_sbd *sdp = sb->s_fs_info;
1484	struct gfs2_quota_lvb *qlvb;	1484	struct gfs2_quota_lvb *qlvb;
1485	struct gfs2_quota_data *qd;	1485	struct gfs2_quota_data *qd;
1486	struct gfs2_holder q_gh;	1486	struct gfs2_holder q_gh;
1487	int error;	1487	int error;
1488	int type;	1488	int type;
1489		1489
1490	memset(fdq, 0, sizeof(struct fs_disk_quota));	1490	memset(fdq, 0, sizeof(struct fs_disk_quota));
1491		1491
1492	if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)	1492	if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
1493	return -ESRCH; /* Crazy XFS error code */	1493	return -ESRCH; /* Crazy XFS error code */
1494		1494
1495	if (qid.type == USRQUOTA)	1495	if (qid.type == USRQUOTA)
1496	type = QUOTA_USER;	1496	type = QUOTA_USER;
1497	else if (qid.type == GRPQUOTA)	1497	else if (qid.type == GRPQUOTA)
1498	type = QUOTA_GROUP;	1498	type = QUOTA_GROUP;
1499	else	1499	else
1500	return -EINVAL;	1500	return -EINVAL;
1501		1501
1502	error = qd_get(sdp, type, from_kqid(&init_user_ns, qid), &qd);	1502	error = qd_get(sdp, type, from_kqid(&init_user_ns, qid), &qd);
1503	if (error)	1503	if (error)
1504	return error;	1504	return error;
1505	error = do_glock(qd, FORCE, &q_gh);	1505	error = do_glock(qd, FORCE, &q_gh);
1506	if (error)	1506	if (error)
1507	goto out;	1507	goto out;
1508		1508
1509	qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;	1509	qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;
1510	fdq->d_version = FS_DQUOT_VERSION;	1510	fdq->d_version = FS_DQUOT_VERSION;
1511	fdq->d_flags = (type == QUOTA_USER) ? FS_USER_QUOTA : FS_GROUP_QUOTA;	1511	fdq->d_flags = (type == QUOTA_USER) ? FS_USER_QUOTA : FS_GROUP_QUOTA;
1512	fdq->d_id = from_kqid(&init_user_ns, qid);	1512	fdq->d_id = from_kqid(&init_user_ns, qid);
1513	fdq->d_blk_hardlimit = be64_to_cpu(qlvb->qb_limit) << sdp->sd_fsb2bb_shift;	1513	fdq->d_blk_hardlimit = be64_to_cpu(qlvb->qb_limit) << sdp->sd_fsb2bb_shift;
1514	fdq->d_blk_softlimit = be64_to_cpu(qlvb->qb_warn) << sdp->sd_fsb2bb_shift;	1514	fdq->d_blk_softlimit = be64_to_cpu(qlvb->qb_warn) << sdp->sd_fsb2bb_shift;
1515	fdq->d_bcount = be64_to_cpu(qlvb->qb_value) << sdp->sd_fsb2bb_shift;	1515	fdq->d_bcount = be64_to_cpu(qlvb->qb_value) << sdp->sd_fsb2bb_shift;
1516		1516
1517	gfs2_glock_dq_uninit(&q_gh);	1517	gfs2_glock_dq_uninit(&q_gh);
1518	out:	1518	out:
1519	qd_put(qd);	1519	qd_put(qd);
1520	return error;	1520	return error;
1521	}	1521	}
1522		1522
1523	/* GFS2 only supports a subset of the XFS fields */	1523	/* GFS2 only supports a subset of the XFS fields */
1524	#define GFS2_FIELDMASK (FS_DQ_BSOFT\|FS_DQ_BHARD\|FS_DQ_BCOUNT)	1524	#define GFS2_FIELDMASK (FS_DQ_BSOFT\|FS_DQ_BHARD\|FS_DQ_BCOUNT)
1525		1525
1526	static int gfs2_set_dqblk(struct super_block *sb, struct kqid qid,	1526	static int gfs2_set_dqblk(struct super_block *sb, struct kqid qid,
1527	struct fs_disk_quota *fdq)	1527	struct fs_disk_quota *fdq)
1528	{	1528	{
1529	struct gfs2_sbd *sdp = sb->s_fs_info;	1529	struct gfs2_sbd *sdp = sb->s_fs_info;
1530	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);	1530	struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
1531	struct gfs2_quota_data *qd;	1531	struct gfs2_quota_data *qd;
1532	struct gfs2_holder q_gh, i_gh;	1532	struct gfs2_holder q_gh, i_gh;
1533	unsigned int data_blocks, ind_blocks;	1533	unsigned int data_blocks, ind_blocks;
1534	unsigned int blocks = 0;	1534	unsigned int blocks = 0;
1535	int alloc_required;	1535	int alloc_required;
1536	loff_t offset;	1536	loff_t offset;
1537	int error;	1537	int error;
1538	int type;	1538	int type;
1539		1539
1540	if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)	1540	if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
1541	return -ESRCH; /* Crazy XFS error code */	1541	return -ESRCH; /* Crazy XFS error code */
1542		1542
1543	switch(qid.type) {	1543	switch(qid.type) {
1544	case USRQUOTA:	1544	case USRQUOTA:
1545	type = QUOTA_USER;	1545	type = QUOTA_USER;
1546	if (fdq->d_flags != FS_USER_QUOTA)	1546	if (fdq->d_flags != FS_USER_QUOTA)
1547	return -EINVAL;	1547	return -EINVAL;
1548	break;	1548	break;
1549	case GRPQUOTA:	1549	case GRPQUOTA:
1550	type = QUOTA_GROUP;	1550	type = QUOTA_GROUP;
1551	if (fdq->d_flags != FS_GROUP_QUOTA)	1551	if (fdq->d_flags != FS_GROUP_QUOTA)
1552	return -EINVAL;	1552	return -EINVAL;
1553	break;	1553	break;
1554	default:	1554	default:
1555	return -EINVAL;	1555	return -EINVAL;
1556	}	1556	}
1557		1557
1558	if (fdq->d_fieldmask & ~GFS2_FIELDMASK)	1558	if (fdq->d_fieldmask & ~GFS2_FIELDMASK)
1559	return -EINVAL;	1559	return -EINVAL;
1560	if (fdq->d_id != from_kqid(&init_user_ns, qid))	1560	if (fdq->d_id != from_kqid(&init_user_ns, qid))
1561	return -EINVAL;	1561	return -EINVAL;
1562		1562
1563	error = qd_get(sdp, type, from_kqid(&init_user_ns, qid), &qd);	1563	error = qd_get(sdp, type, from_kqid(&init_user_ns, qid), &qd);
1564	if (error)	1564	if (error)
1565	return error;	1565	return error;
1566		1566
1567	error = gfs2_rs_alloc(ip);	1567	error = gfs2_rs_alloc(ip);
1568	if (error)	1568	if (error)
1569	goto out_put;	1569	goto out_put;
1570		1570
1571	mutex_lock(&ip->i_inode.i_mutex);	1571	mutex_lock(&ip->i_inode.i_mutex);
1572	error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE, 0, &q_gh);	1572	error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE, 0, &q_gh);
1573	if (error)	1573	if (error)
1574	goto out_unlockput;	1574	goto out_unlockput;
1575	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);	1575	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1576	if (error)	1576	if (error)
1577	goto out_q;	1577	goto out_q;
1578		1578
1579	/* Check for existing entry, if none then alloc new blocks */	1579	/* Check for existing entry, if none then alloc new blocks */
1580	error = update_qd(sdp, qd);	1580	error = update_qd(sdp, qd);
1581	if (error)	1581	if (error)
1582	goto out_i;	1582	goto out_i;
1583		1583
1584	/* If nothing has changed, this is a no-op */	1584	/* If nothing has changed, this is a no-op */
1585	if ((fdq->d_fieldmask & FS_DQ_BSOFT) &&	1585	if ((fdq->d_fieldmask & FS_DQ_BSOFT) &&
1586	((fdq->d_blk_softlimit >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_warn)))	1586	((fdq->d_blk_softlimit >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_warn)))
1587	fdq->d_fieldmask ^= FS_DQ_BSOFT;	1587	fdq->d_fieldmask ^= FS_DQ_BSOFT;
1588		1588
1589	if ((fdq->d_fieldmask & FS_DQ_BHARD) &&	1589	if ((fdq->d_fieldmask & FS_DQ_BHARD) &&
1590	((fdq->d_blk_hardlimit >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_limit)))	1590	((fdq->d_blk_hardlimit >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_limit)))
1591	fdq->d_fieldmask ^= FS_DQ_BHARD;	1591	fdq->d_fieldmask ^= FS_DQ_BHARD;
1592		1592
1593	if ((fdq->d_fieldmask & FS_DQ_BCOUNT) &&	1593	if ((fdq->d_fieldmask & FS_DQ_BCOUNT) &&
1594	((fdq->d_bcount >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_value)))	1594	((fdq->d_bcount >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_value)))
1595	fdq->d_fieldmask ^= FS_DQ_BCOUNT;	1595	fdq->d_fieldmask ^= FS_DQ_BCOUNT;
1596		1596
1597	if (fdq->d_fieldmask == 0)	1597	if (fdq->d_fieldmask == 0)
1598	goto out_i;	1598	goto out_i;
1599		1599
1600	offset = qd2offset(qd);	1600	offset = qd2offset(qd);
1601	alloc_required = gfs2_write_alloc_required(ip, offset, sizeof(struct gfs2_quota));	1601	alloc_required = gfs2_write_alloc_required(ip, offset, sizeof(struct gfs2_quota));
1602	if (gfs2_is_stuffed(ip))	1602	if (gfs2_is_stuffed(ip))
1603	alloc_required = 1;	1603	alloc_required = 1;
1604	if (alloc_required) {	1604	if (alloc_required) {
1605	gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),	1605	gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
1606	&data_blocks, &ind_blocks);	1606	&data_blocks, &ind_blocks);
1607	blocks = 1 + data_blocks + ind_blocks;	1607	blocks = 1 + data_blocks + ind_blocks;
1608	error = gfs2_inplace_reserve(ip, blocks);	1608	error = gfs2_inplace_reserve(ip, blocks, 0);
1609	if (error)	1609	if (error)
1610	goto out_i;	1610	goto out_i;
1611	blocks += gfs2_rg_blocks(ip, blocks);	1611	blocks += gfs2_rg_blocks(ip, blocks);
1612	}	1612	}
1613		1613
1614	/* Some quotas span block boundaries and can update two blocks,	1614	/* Some quotas span block boundaries and can update two blocks,
1615	adding an extra block to the transaction to handle such quotas */	1615	adding an extra block to the transaction to handle such quotas */
1616	error = gfs2_trans_begin(sdp, blocks + RES_DINODE + 2, 0);	1616	error = gfs2_trans_begin(sdp, blocks + RES_DINODE + 2, 0);
1617	if (error)	1617	if (error)
1618	goto out_release;	1618	goto out_release;
1619		1619
1620	/* Apply changes */	1620	/* Apply changes */
1621	error = gfs2_adjust_quota(ip, offset, 0, qd, fdq);	1621	error = gfs2_adjust_quota(ip, offset, 0, qd, fdq);
1622		1622
1623	gfs2_trans_end(sdp);	1623	gfs2_trans_end(sdp);
1624	out_release:	1624	out_release:
1625	if (alloc_required)	1625	if (alloc_required)
1626	gfs2_inplace_release(ip);	1626	gfs2_inplace_release(ip);
1627	out_i:	1627	out_i:
1628	gfs2_glock_dq_uninit(&i_gh);	1628	gfs2_glock_dq_uninit(&i_gh);
1629	out_q:	1629	out_q:
1630	gfs2_glock_dq_uninit(&q_gh);	1630	gfs2_glock_dq_uninit(&q_gh);
1631	out_unlockput:	1631	out_unlockput:
1632	mutex_unlock(&ip->i_inode.i_mutex);	1632	mutex_unlock(&ip->i_inode.i_mutex);
1633	out_put:	1633	out_put:
1634	qd_put(qd);	1634	qd_put(qd);
1635	return error;	1635	return error;
1636	}	1636	}
1637		1637
1638	const struct quotactl_ops gfs2_quotactl_ops = {	1638	const struct quotactl_ops gfs2_quotactl_ops = {
1639	.quota_sync = gfs2_quota_sync,	1639	.quota_sync = gfs2_quota_sync,
1640	.get_xstate = gfs2_quota_get_xstate,	1640	.get_xstate = gfs2_quota_get_xstate,
1641	.get_dqblk = gfs2_get_dqblk,	1641	.get_dqblk = gfs2_get_dqblk,
1642	.set_dqblk = gfs2_set_dqblk,	1642	.set_dqblk = gfs2_set_dqblk,
1643	};	1643	};
1644		1644

fs/gfs2/rgrp.c

Diff comments View file @ 9dbe961

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2008 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 version 2.
  */
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <linux/fs.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/prefetch.h>
 #include <linux/blkdev.h>
 #include <linux/rbtree.h>
+#include <linux/random.h>
 #include "gfs2.h"
 #include "incore.h"
 #include "glock.h"
 #include "glops.h"
 #include "lops.h"
 #include "meta_io.h"
 #include "quota.h"
 #include "rgrp.h"
 #include "super.h"
 #include "trans.h"
 #include "util.h"
 #include "log.h"
 #include "inode.h"
 #include "trace_gfs2.h"
 #define BFITNOENT ((u32)~0)
 #define NO_BLOCK ((u64)~0)
 #if BITS_PER_LONG == 32
 #define LBITMASK   (0x55555555UL)
 #define LBITSKIP55 (0x55555555UL)
 #define LBITSKIP00 (0x00000000UL)
 #else
 #define LBITMASK   (0x5555555555555555UL)
 #define LBITSKIP55 (0x5555555555555555UL)
 #define LBITSKIP00 (0x0000000000000000UL)
 #endif
 /*
  * These routines are used by the resource group routines (rgrp.c)
  * to keep track of block allocation.  Each block is represented by two
  * bits.  So, each byte represents GFS2_NBBY (i.e. 4) blocks.
  *
  * 0 = Free
  * 1 = Used (not metadata)
  * 2 = Unlinked (still in use) inode
  * 3 = Used (metadata)
  */
 static const char valid_change[16] = {
 	        /* current */
 	/* n */ 0, 1, 1, 1,
 	/* e */ 1, 0, 0, 0,
 	/* w */ 0, 0, 0, 1,
 	        1, 0, 0, 0
 };
 static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 minext,
                          const struct gfs2_inode *ip, bool nowrap);
 /**
  * gfs2_setbit - Set a bit in the bitmaps
  * @rbm: The position of the bit to set
  * @do_clone: Also set the clone bitmap, if it exists
  * @new_state: the new state of the block
  *
  */
 static inline void gfs2_setbit(const struct gfs2_rbm *rbm, bool do_clone,
 			       unsigned char new_state)
 {
 	unsigned char *byte1, *byte2, *end, cur_state;
 	unsigned int buflen = rbm->bi->bi_len;
 	const unsigned int bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
 	byte1 = rbm->bi->bi_bh->b_data + rbm->bi->bi_offset + (rbm->offset / GFS2_NBBY);
 	end = rbm->bi->bi_bh->b_data + rbm->bi->bi_offset + buflen;
 	BUG_ON(byte1 >= end);
 	cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
 	if (unlikely(!valid_change[new_state * 4 + cur_state])) {
 		printk(KERN_WARNING "GFS2: buf_blk = 0x%x old_state=%d, "
 		       "new_state=%d\n", rbm->offset, cur_state, new_state);
 		printk(KERN_WARNING "GFS2: rgrp=0x%llx bi_start=0x%x\n",
 		       (unsigned long long)rbm->rgd->rd_addr,
 		       rbm->bi->bi_start);
 		printk(KERN_WARNING "GFS2: bi_offset=0x%x bi_len=0x%x\n",
 		       rbm->bi->bi_offset, rbm->bi->bi_len);
 		dump_stack();
 		gfs2_consist_rgrpd(rbm->rgd);
 		return;
 	}
 	*byte1 ^= (cur_state ^ new_state) << bit;
 	if (do_clone && rbm->bi->bi_clone) {
 		byte2 = rbm->bi->bi_clone + rbm->bi->bi_offset + (rbm->offset / GFS2_NBBY);
 		cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
 		*byte2 ^= (cur_state ^ new_state) << bit;
 	}
 }
 /**
  * gfs2_testbit - test a bit in the bitmaps
  * @rbm: The bit to test
  *
  * Returns: The two bit block state of the requested bit
  */
 static inline u8 gfs2_testbit(const struct gfs2_rbm *rbm)
 {
 	const u8 *buffer = rbm->bi->bi_bh->b_data + rbm->bi->bi_offset;
 	const u8 *byte;
 	unsigned int bit;
 	byte = buffer + (rbm->offset / GFS2_NBBY);
 	bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
 	return (*byte >> bit) & GFS2_BIT_MASK;
 }
 /**
  * gfs2_bit_search
  * @ptr: Pointer to bitmap data
  * @mask: Mask to use (normally 0x55555.... but adjusted for search start)
  * @state: The state we are searching for
  *
  * We xor the bitmap data with a patter which is the bitwise opposite
  * of what we are looking for, this gives rise to a pattern of ones
  * wherever there is a match. Since we have two bits per entry, we
  * take this pattern, shift it down by one place and then and it with
  * the original. All the even bit positions (0,2,4, etc) then represent
  * successful matches, so we mask with 0x55555..... to remove the unwanted
  * odd bit positions.
  *
  * This allows searching of a whole u64 at once (32 blocks) with a
  * single test (on 64 bit arches).
  */
 static inline u64 gfs2_bit_search(const __le64 *ptr, u64 mask, u8 state)
 {
 	u64 tmp;
 	static const u64 search[] = {
 		[0] = 0xffffffffffffffffULL,
 		[1] = 0xaaaaaaaaaaaaaaaaULL,
 		[2] = 0x5555555555555555ULL,
 		[3] = 0x0000000000000000ULL,
 	};
 	tmp = le64_to_cpu(*ptr) ^ search[state];
 	tmp &= (tmp >> 1);
 	tmp &= mask;
 	return tmp;
 }
 /**
  * rs_cmp - multi-block reservation range compare
  * @blk: absolute file system block number of the new reservation
  * @len: number of blocks in the new reservation
  * @rs: existing reservation to compare against
  *
  * returns: 1 if the block range is beyond the reach of the reservation
  *         -1 if the block range is before the start of the reservation
  *          0 if the block range overlaps with the reservation
  */
 static inline int rs_cmp(u64 blk, u32 len, struct gfs2_blkreserv *rs)
 {
 	u64 startblk = gfs2_rbm_to_block(&rs->rs_rbm);
 	if (blk >= startblk + rs->rs_free)
 		return 1;
 	if (blk + len - 1 < startblk)
 		return -1;
 	return 0;
 }
 /**
  * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
  *       a block in a given allocation state.
  * @buf: the buffer that holds the bitmaps
  * @len: the length (in bytes) of the buffer
  * @goal: start search at this block's bit-pair (within @buffer)
  * @state: GFS2_BLKST_XXX the state of the block we're looking for.
  *
  * Scope of @goal and returned block number is only within this bitmap buffer,
  * not entire rgrp or filesystem.  @buffer will be offset from the actual
  * beginning of a bitmap block buffer, skipping any header structures, but
  * headers are always a multiple of 64 bits long so that the buffer is
  * always aligned to a 64 bit boundary.
  *
  * The size of the buffer is in bytes, but is it assumed that it is
  * always ok to read a complete multiple of 64 bits at the end
  * of the block in case the end is no aligned to a natural boundary.
  *
  * Return: the block number (bitmap buffer scope) that was found
  */
 static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
 		       u32 goal, u8 state)
 {
 	u32 spoint = (goal << 1) & ((8*sizeof(u64)) - 1);
 	const __le64 *ptr = ((__le64 *)buf) + (goal >> 5);
 	const __le64 *end = (__le64 *)(buf + ALIGN(len, sizeof(u64)));
 	u64 tmp;
 	u64 mask = 0x5555555555555555ULL;
 	u32 bit;
 	/* Mask off bits we don't care about at the start of the search */
 	mask <<= spoint;
 	tmp = gfs2_bit_search(ptr, mask, state);
 	ptr++;
 	while(tmp == 0 && ptr < end) {
 		tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
 		ptr++;
 	}
 	/* Mask off any bits which are more than len bytes from the start */
 	if (ptr == end && (len & (sizeof(u64) - 1)))
 		tmp &= (((u64)~0) >> (64 - 8*(len & (sizeof(u64) - 1))));
 	/* Didn't find anything, so return */
 	if (tmp == 0)
 		return BFITNOENT;
 	ptr--;
 	bit = __ffs64(tmp);
 	bit /= 2;	/* two bits per entry in the bitmap */
 	return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
 }
 /**
  * gfs2_rbm_from_block - Set the rbm based upon rgd and block number
  * @rbm: The rbm with rgd already set correctly
  * @block: The block number (filesystem relative)
  *
  * This sets the bi and offset members of an rbm based on a
  * resource group and a filesystem relative block number. The
  * resource group must be set in the rbm on entry, the bi and
  * offset members will be set by this function.
  *
  * Returns: 0 on success, or an error code
  */
 static int gfs2_rbm_from_block(struct gfs2_rbm *rbm, u64 block)
 {
 	u64 rblock = block - rbm->rgd->rd_data0;
 	u32 x;
 	if (WARN_ON_ONCE(rblock > UINT_MAX))
 		return -EINVAL;
 	if (block >= rbm->rgd->rd_data0 + rbm->rgd->rd_data)
 		return -E2BIG;
 	rbm->bi = rbm->rgd->rd_bits;
 	rbm->offset = (u32)(rblock);
 	/* Check if the block is within the first block */
 	if (rbm->offset < (rbm->bi->bi_start + rbm->bi->bi_len) * GFS2_NBBY)
 		return 0;
 	/* Adjust for the size diff between gfs2_meta_header and gfs2_rgrp */
 	rbm->offset += (sizeof(struct gfs2_rgrp) -
 			sizeof(struct gfs2_meta_header)) * GFS2_NBBY;
 	x = rbm->offset / rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
 	rbm->offset -= x * rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
 	rbm->bi += x;
 	return 0;
 }
 /**
  * gfs2_unaligned_extlen - Look for free blocks which are not byte aligned
  * @rbm: Position to search (value/result)
  * @n_unaligned: Number of unaligned blocks to check
  * @len: Decremented for each block found (terminate on zero)
  *
  * Returns: true if a non-free block is encountered
  */
 static bool gfs2_unaligned_extlen(struct gfs2_rbm *rbm, u32 n_unaligned, u32 *len)
 {
 	u64 block;
 	u32 n;
 	u8 res;
 	for (n = 0; n < n_unaligned; n++) {
 		res = gfs2_testbit(rbm);
 		if (res != GFS2_BLKST_FREE)
 			return true;
 		(*len)--;
 		if (*len == 0)
 			return true;
 		block = gfs2_rbm_to_block(rbm);
 		if (gfs2_rbm_from_block(rbm, block + 1))
 			return true;
 	}
 	return false;
 }
 /**
  * gfs2_free_extlen - Return extent length of free blocks
  * @rbm: Starting position
  * @len: Max length to check
  *
  * Starting at the block specified by the rbm, see how many free blocks
  * there are, not reading more than len blocks ahead. This can be done
  * using memchr_inv when the blocks are byte aligned, but has to be done
  * on a block by block basis in case of unaligned blocks. Also this
  * function can cope with bitmap boundaries (although it must stop on
  * a resource group boundary)
  *
  * Returns: Number of free blocks in the extent
  */
 static u32 gfs2_free_extlen(const struct gfs2_rbm *rrbm, u32 len)
 {
 	struct gfs2_rbm rbm = *rrbm;
 	u32 n_unaligned = rbm.offset & 3;
 	u32 size = len;
 	u32 bytes;
 	u32 chunk_size;
 	u8 *ptr, *start, *end;
 	u64 block;
 	if (n_unaligned &&
 	    gfs2_unaligned_extlen(&rbm, 4 - n_unaligned, &len))
 		goto out;
 	n_unaligned = len & 3;
 	/* Start is now byte aligned */
 	while (len > 3) {
 		start = rbm.bi->bi_bh->b_data;
 		if (rbm.bi->bi_clone)
 			start = rbm.bi->bi_clone;
 		end = start + rbm.bi->bi_bh->b_size;
 		start += rbm.bi->bi_offset;
 		BUG_ON(rbm.offset & 3);
 		start += (rbm.offset / GFS2_NBBY);
 		bytes = min_t(u32, len / GFS2_NBBY, (end - start));
 		ptr = memchr_inv(start, 0, bytes);
 		chunk_size = ((ptr == NULL) ? bytes : (ptr - start));
 		chunk_size *= GFS2_NBBY;
 		BUG_ON(len < chunk_size);
 		len -= chunk_size;
 		block = gfs2_rbm_to_block(&rbm);
 		gfs2_rbm_from_block(&rbm, block + chunk_size);
 		n_unaligned = 3;
 		if (ptr)
 			break;
 		n_unaligned = len & 3;
 	}
 	/* Deal with any bits left over at the end */
 	if (n_unaligned)
 		gfs2_unaligned_extlen(&rbm, n_unaligned, &len);
 out:
 	return size - len;
 }
 /**
  * gfs2_bitcount - count the number of bits in a certain state
  * @rgd: the resource group descriptor
  * @buffer: the buffer that holds the bitmaps
  * @buflen: the length (in bytes) of the buffer
  * @state: the state of the block we're looking for
  *
  * Returns: The number of bits
  */
 static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
 			 unsigned int buflen, u8 state)
 {
 	const u8 *byte = buffer;
 	const u8 *end = buffer + buflen;
 	const u8 state1 = state << 2;
 	const u8 state2 = state << 4;
 	const u8 state3 = state << 6;
 	u32 count = 0;
 	for (; byte < end; byte++) {
 		if (((*byte) & 0x03) == state)
 			count++;
 		if (((*byte) & 0x0C) == state1)
 			count++;
 		if (((*byte) & 0x30) == state2)
 			count++;
 		if (((*byte) & 0xC0) == state3)
 			count++;
 	}
 	return count;
 }
 /**
  * gfs2_rgrp_verify - Verify that a resource group is consistent
  * @rgd: the rgrp
  *
  */
 void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
 {
 	struct gfs2_sbd *sdp = rgd->rd_sbd;
 	struct gfs2_bitmap *bi = NULL;
 	u32 length = rgd->rd_length;
 	u32 count[4], tmp;
 	int buf, x;
 	memset(count, 0, 4 * sizeof(u32));
 	/* Count # blocks in each of 4 possible allocation states */
 	for (buf = 0; buf < length; buf++) {
 		bi = rgd->rd_bits + buf;
 		for (x = 0; x < 4; x++)
 			count[x] += gfs2_bitcount(rgd,
 						  bi->bi_bh->b_data +
 						  bi->bi_offset,
 						  bi->bi_len, x);
 	}
 	if (count[0] != rgd->rd_free) {
 		if (gfs2_consist_rgrpd(rgd))
 			fs_err(sdp, "free data mismatch:  %u != %u\n",
 			       count[0], rgd->rd_free);
 		return;
 	}
 	tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
 	if (count[1] != tmp) {
 		if (gfs2_consist_rgrpd(rgd))
 			fs_err(sdp, "used data mismatch:  %u != %u\n",
 			       count[1], tmp);
 		return;
 	}
 	if (count[2] + count[3] != rgd->rd_dinodes) {
 		if (gfs2_consist_rgrpd(rgd))
 			fs_err(sdp, "used metadata mismatch:  %u != %u\n",
 			       count[2] + count[3], rgd->rd_dinodes);
 		return;
 	}
 }
 static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block)
 {
 	u64 first = rgd->rd_data0;
 	u64 last = first + rgd->rd_data;
 	return first <= block && block < last;
 }
 /**
  * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
  * @sdp: The GFS2 superblock
  * @blk: The data block number
  * @exact: True if this needs to be an exact match
  *
  * Returns: The resource group, or NULL if not found
  */
 struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
 {
 	struct rb_node *n, *next;
 	struct gfs2_rgrpd *cur;
 	spin_lock(&sdp->sd_rindex_spin);
 	n = sdp->sd_rindex_tree.rb_node;
 	while (n) {
 		cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
 		next = NULL;
 		if (blk < cur->rd_addr)
 			next = n->rb_left;
 		else if (blk >= cur->rd_data0 + cur->rd_data)
 			next = n->rb_right;
 		if (next == NULL) {
 			spin_unlock(&sdp->sd_rindex_spin);
 			if (exact) {
 				if (blk < cur->rd_addr)
 					return NULL;
 				if (blk >= cur->rd_data0 + cur->rd_data)
 					return NULL;
 			}
 			return cur;
 		}
 		n = next;
 	}
 	spin_unlock(&sdp->sd_rindex_spin);
 	return NULL;
 }
 /**
  * gfs2_rgrpd_get_first - get the first Resource Group in the filesystem
  * @sdp: The GFS2 superblock
  *
  * Returns: The first rgrp in the filesystem
  */
 struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp)
 {
 	const struct rb_node *n;
 	struct gfs2_rgrpd *rgd;
 	spin_lock(&sdp->sd_rindex_spin);
 	n = rb_first(&sdp->sd_rindex_tree);
 	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
 	spin_unlock(&sdp->sd_rindex_spin);
 	return rgd;
 }
 /**
  * gfs2_rgrpd_get_next - get the next RG
  * @rgd: the resource group descriptor
  *
  * Returns: The next rgrp
  */
 struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
 {
 	struct gfs2_sbd *sdp = rgd->rd_sbd;
 	const struct rb_node *n;
 	spin_lock(&sdp->sd_rindex_spin);
 	n = rb_next(&rgd->rd_node);
 	if (n == NULL)
 		n = rb_first(&sdp->sd_rindex_tree);
 	if (unlikely(&rgd->rd_node == n)) {
 		spin_unlock(&sdp->sd_rindex_spin);
 		return NULL;
 	}
 	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
 	spin_unlock(&sdp->sd_rindex_spin);
 	return rgd;
 }
 void gfs2_free_clones(struct gfs2_rgrpd *rgd)
 {
 	int x;
 	for (x = 0; x < rgd->rd_length; x++) {
 		struct gfs2_bitmap *bi = rgd->rd_bits + x;
 		kfree(bi->bi_clone);
 		bi->bi_clone = NULL;
 	}
 }
 /**
  * gfs2_rs_alloc - make sure we have a reservation assigned to the inode
  * @ip: the inode for this reservation
  */
 int gfs2_rs_alloc(struct gfs2_inode *ip)
 {
 	struct gfs2_blkreserv *res;
 	if (ip->i_res)
 		return 0;
 	res = kmem_cache_zalloc(gfs2_rsrv_cachep, GFP_NOFS);
 	if (!res)
 		return -ENOMEM;
 	RB_CLEAR_NODE(&res->rs_node);
 	down_write(&ip->i_rw_mutex);
 	if (ip->i_res)
 		kmem_cache_free(gfs2_rsrv_cachep, res);
 	else
 		ip->i_res = res;
 	up_write(&ip->i_rw_mutex);
 	return 0;
 }
 static void dump_rs(struct seq_file *seq, const struct gfs2_blkreserv *rs)
 {
 	gfs2_print_dbg(seq, "  B: n:%llu s:%llu b:%u f:%u\n",
 		       (unsigned long long)rs->rs_inum,
 		       (unsigned long long)gfs2_rbm_to_block(&rs->rs_rbm),
 		       rs->rs_rbm.offset, rs->rs_free);
 }
 /**
  * __rs_deltree - remove a multi-block reservation from the rgd tree
  * @rs: The reservation to remove
  *
  */
 static void __rs_deltree(struct gfs2_inode *ip, struct gfs2_blkreserv *rs)
 {
 	struct gfs2_rgrpd *rgd;
 	if (!gfs2_rs_active(rs))
 		return;
 	rgd = rs->rs_rbm.rgd;
 	trace_gfs2_rs(rs, TRACE_RS_TREEDEL);
 	rb_erase(&rs->rs_node, &rgd->rd_rstree);
 	RB_CLEAR_NODE(&rs->rs_node);
 	if (rs->rs_free) {
 		/* return reserved blocks to the rgrp and the ip */
 		BUG_ON(rs->rs_rbm.rgd->rd_reserved < rs->rs_free);
 		rs->rs_rbm.rgd->rd_reserved -= rs->rs_free;
 		rs->rs_free = 0;
 		clear_bit(GBF_FULL, &rs->rs_rbm.bi->bi_flags);
 		smp_mb__after_clear_bit();
 	}
 }
 /**
  * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
  * @rs: The reservation to remove
  *
  */
 void gfs2_rs_deltree(struct gfs2_inode *ip, struct gfs2_blkreserv *rs)
 {
 	struct gfs2_rgrpd *rgd;
 	rgd = rs->rs_rbm.rgd;
 	if (rgd) {
 		spin_lock(&rgd->rd_rsspin);
 		__rs_deltree(ip, rs);
 		spin_unlock(&rgd->rd_rsspin);
 	}
 }
 /**
  * gfs2_rs_delete - delete a multi-block reservation
  * @ip: The inode for this reservation
  *
  */
 void gfs2_rs_delete(struct gfs2_inode *ip)
 {
 	down_write(&ip->i_rw_mutex);
 	if (ip->i_res) {
 		gfs2_rs_deltree(ip, ip->i_res);
 		BUG_ON(ip->i_res->rs_free);
 		kmem_cache_free(gfs2_rsrv_cachep, ip->i_res);
 		ip->i_res = NULL;
 	}
 	up_write(&ip->i_rw_mutex);
 }
 /**
  * return_all_reservations - return all reserved blocks back to the rgrp.
  * @rgd: the rgrp that needs its space back
  *
  * We previously reserved a bunch of blocks for allocation. Now we need to
  * give them back. This leave the reservation structures in tact, but removes
  * all of their corresponding "no-fly zones".
  */
 static void return_all_reservations(struct gfs2_rgrpd *rgd)
 {
 	struct rb_node *n;
 	struct gfs2_blkreserv *rs;
 	spin_lock(&rgd->rd_rsspin);
 	while ((n = rb_first(&rgd->rd_rstree))) {
 		rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
 		__rs_deltree(NULL, rs);
 	}
 	spin_unlock(&rgd->rd_rsspin);
 }
 void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
 {
 	struct rb_node *n;
 	struct gfs2_rgrpd *rgd;
 	struct gfs2_glock *gl;
 	while ((n = rb_first(&sdp->sd_rindex_tree))) {
 		rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
 		gl = rgd->rd_gl;
 		rb_erase(n, &sdp->sd_rindex_tree);
 		if (gl) {
 			spin_lock(&gl->gl_spin);
 			gl->gl_object = NULL;
 			spin_unlock(&gl->gl_spin);
 			gfs2_glock_add_to_lru(gl);
 			gfs2_glock_put(gl);
 		}
 		gfs2_free_clones(rgd);
 		kfree(rgd->rd_bits);
 		return_all_reservations(rgd);
 		kmem_cache_free(gfs2_rgrpd_cachep, rgd);
 	}
 }
 static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd)
 {
 	printk(KERN_INFO "  ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
 	printk(KERN_INFO "  ri_length = %u\n", rgd->rd_length);
 	printk(KERN_INFO "  ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
 	printk(KERN_INFO "  ri_data = %u\n", rgd->rd_data);
 	printk(KERN_INFO "  ri_bitbytes = %u\n", rgd->rd_bitbytes);
 }
 /**
  * gfs2_compute_bitstructs - Compute the bitmap sizes
  * @rgd: The resource group descriptor
  *
  * Calculates bitmap descriptors, one for each block that contains bitmap data
  *
  * Returns: errno
  */
 static int compute_bitstructs(struct gfs2_rgrpd *rgd)
 {
 	struct gfs2_sbd *sdp = rgd->rd_sbd;
 	struct gfs2_bitmap *bi;
 	u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
 	u32 bytes_left, bytes;
 	int x;
 	if (!length)
 		return -EINVAL;
 	rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
 	if (!rgd->rd_bits)
 		return -ENOMEM;
 	bytes_left = rgd->rd_bitbytes;
 	for (x = 0; x < length; x++) {
 		bi = rgd->rd_bits + x;
 		bi->bi_flags = 0;
 		/* small rgrp; bitmap stored completely in header block */
 		if (length == 1) {
 			bytes = bytes_left;
 			bi->bi_offset = sizeof(struct gfs2_rgrp);
 			bi->bi_start = 0;
 			bi->bi_len = bytes;
 		/* header block */
 		} else if (x == 0) {
 			bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
 			bi->bi_offset = sizeof(struct gfs2_rgrp);
 			bi->bi_start = 0;
 			bi->bi_len = bytes;
 		/* last block */
 		} else if (x + 1 == length) {
 			bytes = bytes_left;
 			bi->bi_offset = sizeof(struct gfs2_meta_header);
 			bi->bi_start = rgd->rd_bitbytes - bytes_left;
 			bi->bi_len = bytes;
 		/* other blocks */
 		} else {
 			bytes = sdp->sd_sb.sb_bsize -
 				sizeof(struct gfs2_meta_header);
 			bi->bi_offset = sizeof(struct gfs2_meta_header);
 			bi->bi_start = rgd->rd_bitbytes - bytes_left;
 			bi->bi_len = bytes;
 		}
 		bytes_left -= bytes;
 	}
 	if (bytes_left) {
 		gfs2_consist_rgrpd(rgd);
 		return -EIO;
 	}
 	bi = rgd->rd_bits + (length - 1);
 	if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
 		if (gfs2_consist_rgrpd(rgd)) {
 			gfs2_rindex_print(rgd);
 			fs_err(sdp, "start=%u len=%u offset=%u\n",
 			       bi->bi_start, bi->bi_len, bi->bi_offset);
 		}
 		return -EIO;
 	}
 	return 0;
 }
 /**
  * gfs2_ri_total - Total up the file system space, according to the rindex.
  * @sdp: the filesystem
  *
  */
 u64 gfs2_ri_total(struct gfs2_sbd *sdp)
 {
 	u64 total_data = 0;
 	struct inode *inode = sdp->sd_rindex;
 	struct gfs2_inode *ip = GFS2_I(inode);
 	char buf[sizeof(struct gfs2_rindex)];
 	int error, rgrps;
 	for (rgrps = 0;; rgrps++) {
 		loff_t pos = rgrps * sizeof(struct gfs2_rindex);
 		if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
 			break;
 		error = gfs2_internal_read(ip, buf, &pos,
 					   sizeof(struct gfs2_rindex));
 		if (error != sizeof(struct gfs2_rindex))
 			break;
 		total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
 	}
 	return total_data;
 }
 static int rgd_insert(struct gfs2_rgrpd *rgd)
 {
 	struct gfs2_sbd *sdp = rgd->rd_sbd;
 	struct rb_node **newn = &sdp->sd_rindex_tree.rb_node, *parent = NULL;
 	/* Figure out where to put new node */
 	while (*newn) {
 		struct gfs2_rgrpd *cur = rb_entry(*newn, struct gfs2_rgrpd,
 						  rd_node);
 		parent = *newn;
 		if (rgd->rd_addr < cur->rd_addr)
 			newn = &((*newn)->rb_left);
 		else if (rgd->rd_addr > cur->rd_addr)
 			newn = &((*newn)->rb_right);
 		else
 			return -EEXIST;
 	}
 	rb_link_node(&rgd->rd_node, parent, newn);
 	rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
 	sdp->sd_rgrps++;
 	return 0;
 }
 /**
  * read_rindex_entry - Pull in a new resource index entry from the disk
  * @ip: Pointer to the rindex inode
  *
  * Returns: 0 on success, > 0 on EOF, error code otherwise
  */
 static int read_rindex_entry(struct gfs2_inode *ip)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
 	struct gfs2_rindex buf;
 	int error;
 	struct gfs2_rgrpd *rgd;
 	if (pos >= i_size_read(&ip->i_inode))
 		return 1;
 	error = gfs2_internal_read(ip, (char *)&buf, &pos,
 				   sizeof(struct gfs2_rindex));
 	if (error != sizeof(struct gfs2_rindex))
 		return (error == 0) ? 1 : error;
 	rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
 	error = -ENOMEM;
 	if (!rgd)
 		return error;
 	rgd->rd_sbd = sdp;
 	rgd->rd_addr = be64_to_cpu(buf.ri_addr);
 	rgd->rd_length = be32_to_cpu(buf.ri_length);
 	rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
 	rgd->rd_data = be32_to_cpu(buf.ri_data);
 	rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
 	spin_lock_init(&rgd->rd_rsspin);
 	error = compute_bitstructs(rgd);
 	if (error)
 		goto fail;
 	error = gfs2_glock_get(sdp, rgd->rd_addr,
 			       &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
 	if (error)
 		goto fail;
 	rgd->rd_gl->gl_object = rgd;
 	rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lvb;
 	rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
 	if (rgd->rd_data > sdp->sd_max_rg_data)
 		sdp->sd_max_rg_data = rgd->rd_data;
 	spin_lock(&sdp->sd_rindex_spin);
 	error = rgd_insert(rgd);
 	spin_unlock(&sdp->sd_rindex_spin);
 	if (!error)
 		return 0;
 	error = 0; /* someone else read in the rgrp; free it and ignore it */
 	gfs2_glock_put(rgd->rd_gl);
 fail:
 	kfree(rgd->rd_bits);
 	kmem_cache_free(gfs2_rgrpd_cachep, rgd);
 	return error;
 }
 /**
  * gfs2_ri_update - Pull in a new resource index from the disk
  * @ip: pointer to the rindex inode
  *
  * Returns: 0 on successful update, error code otherwise
  */
 static int gfs2_ri_update(struct gfs2_inode *ip)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	int error;
 	do {
 		error = read_rindex_entry(ip);
 	} while (error == 0);
 	if (error < 0)
 		return error;
 	sdp->sd_rindex_uptodate = 1;
 	return 0;
 }
 /**
  * gfs2_rindex_update - Update the rindex if required
  * @sdp: The GFS2 superblock
  *
  * We grab a lock on the rindex inode to make sure that it doesn't
  * change whilst we are performing an operation. We keep this lock
  * for quite long periods of time compared to other locks. This
  * doesn't matter, since it is shared and it is very, very rarely
  * accessed in the exclusive mode (i.e. only when expanding the filesystem).
  *
  * This makes sure that we're using the latest copy of the resource index
  * special file, which might have been updated if someone expanded the
  * filesystem (via gfs2_grow utility), which adds new resource groups.
  *
  * Returns: 0 on succeess, error code otherwise
  */
 int gfs2_rindex_update(struct gfs2_sbd *sdp)
 {
 	struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
 	struct gfs2_glock *gl = ip->i_gl;
 	struct gfs2_holder ri_gh;
 	int error = 0;
 	int unlock_required = 0;
 	/* Read new copy from disk if we don't have the latest */
 	if (!sdp->sd_rindex_uptodate) {
 		if (!gfs2_glock_is_locked_by_me(gl)) {
 			error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, &ri_gh);
 			if (error)
 				return error;
 			unlock_required = 1;
 		}
 		if (!sdp->sd_rindex_uptodate)
 			error = gfs2_ri_update(ip);
 		if (unlock_required)
 			gfs2_glock_dq_uninit(&ri_gh);
 	}
 	return error;
 }
 static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
 {
 	const struct gfs2_rgrp *str = buf;
 	u32 rg_flags;
 	rg_flags = be32_to_cpu(str->rg_flags);
 	rg_flags &= ~GFS2_RDF_MASK;
 	rgd->rd_flags &= GFS2_RDF_MASK;
 	rgd->rd_flags |= rg_flags;
 	rgd->rd_free = be32_to_cpu(str->rg_free);
 	rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
 	rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
 }
 static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
 {
 	struct gfs2_rgrp *str = buf;
 	str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
 	str->rg_free = cpu_to_be32(rgd->rd_free);
 	str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
 	str->__pad = cpu_to_be32(0);
 	str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
 	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
 }
 static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
 {
 	struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
 	struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
 	if (rgl->rl_flags != str->rg_flags || rgl->rl_free != str->rg_free ||
 	    rgl->rl_dinodes != str->rg_dinodes ||
 	    rgl->rl_igeneration != str->rg_igeneration)
 		return 0;
 	return 1;
 }
 static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb *rgl, const void *buf)
 {
 	const struct gfs2_rgrp *str = buf;
 	rgl->rl_magic = cpu_to_be32(GFS2_MAGIC);
 	rgl->rl_flags = str->rg_flags;
 	rgl->rl_free = str->rg_free;
 	rgl->rl_dinodes = str->rg_dinodes;
 	rgl->rl_igeneration = str->rg_igeneration;
 	rgl->__pad = 0UL;
 }
 static void update_rgrp_lvb_unlinked(struct gfs2_rgrpd *rgd, u32 change)
 {
 	struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
 	u32 unlinked = be32_to_cpu(rgl->rl_unlinked) + change;
 	rgl->rl_unlinked = cpu_to_be32(unlinked);
 }
 static u32 count_unlinked(struct gfs2_rgrpd *rgd)
 {
 	struct gfs2_bitmap *bi;
 	const u32 length = rgd->rd_length;
 	const u8 *buffer = NULL;
 	u32 i, goal, count = 0;
 	for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
 		goal = 0;
 		buffer = bi->bi_bh->b_data + bi->bi_offset;
 		WARN_ON(!buffer_uptodate(bi->bi_bh));
 		while (goal < bi->bi_len * GFS2_NBBY) {
 			goal = gfs2_bitfit(buffer, bi->bi_len, goal,
 					   GFS2_BLKST_UNLINKED);
 			if (goal == BFITNOENT)
 				break;
 			count++;
 			goal++;
 		}
 	}
 	return count;
 }
 /**
  * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
  * @rgd: the struct gfs2_rgrpd describing the RG to read in
  *
  * Read in all of a Resource Group's header and bitmap blocks.
  * Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.
  *
  * Returns: errno
  */
 int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
 {
 	struct gfs2_sbd *sdp = rgd->rd_sbd;
 	struct gfs2_glock *gl = rgd->rd_gl;
 	unsigned int length = rgd->rd_length;
 	struct gfs2_bitmap *bi;
 	unsigned int x, y;
 	int error;
 	if (rgd->rd_bits[0].bi_bh != NULL)
 		return 0;
 	for (x = 0; x < length; x++) {
 		bi = rgd->rd_bits + x;
 		error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
 		if (error)
 			goto fail;
 	}
 	for (y = length; y--;) {
 		bi = rgd->rd_bits + y;
 		error = gfs2_meta_wait(sdp, bi->bi_bh);
 		if (error)
 			goto fail;
 		if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
 					      GFS2_METATYPE_RG)) {
 			error = -EIO;
 			goto fail;
 		}
 	}
 	if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
 		for (x = 0; x < length; x++)
 			clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
 		gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
 		rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
 		rgd->rd_free_clone = rgd->rd_free;
 	}
 	if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
 		rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
 		gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
 				     rgd->rd_bits[0].bi_bh->b_data);
 	}
 	else if (sdp->sd_args.ar_rgrplvb) {
 		if (!gfs2_rgrp_lvb_valid(rgd)){
 			gfs2_consist_rgrpd(rgd);
 			error = -EIO;
 			goto fail;
 		}
 		if (rgd->rd_rgl->rl_unlinked == 0)
 			rgd->rd_flags &= ~GFS2_RDF_CHECK;
 	}
 	return 0;
 fail:
 	while (x--) {
 		bi = rgd->rd_bits + x;
 		brelse(bi->bi_bh);
 		bi->bi_bh = NULL;
 		gfs2_assert_warn(sdp, !bi->bi_clone);
 	}
 	return error;
 }
 int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
 {
 	u32 rl_flags;
 	if (rgd->rd_flags & GFS2_RDF_UPTODATE)
 		return 0;
 	if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
 		return gfs2_rgrp_bh_get(rgd);
 	rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
 	rl_flags &= ~GFS2_RDF_MASK;
 	rgd->rd_flags &= GFS2_RDF_MASK;
 	rgd->rd_flags |= (rl_flags | GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
 	if (rgd->rd_rgl->rl_unlinked == 0)
 		rgd->rd_flags &= ~GFS2_RDF_CHECK;
 	rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
 	rgd->rd_free_clone = rgd->rd_free;
 	rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
 	rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
 	return 0;
 }
 int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
 {
 	struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
 	struct gfs2_sbd *sdp = rgd->rd_sbd;
 	if (gh->gh_flags & GL_SKIP && sdp->sd_args.ar_rgrplvb)
 		return 0;
 	return gfs2_rgrp_bh_get((struct gfs2_rgrpd *)gh->gh_gl->gl_object);
 }
 /**
  * gfs2_rgrp_go_unlock - Release RG bitmaps read in with gfs2_rgrp_bh_get()
  * @gh: The glock holder for the resource group
  *
  */
 void gfs2_rgrp_go_unlock(struct gfs2_holder *gh)
 {
 	struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
 	int x, length = rgd->rd_length;
 	for (x = 0; x < length; x++) {
 		struct gfs2_bitmap *bi = rgd->rd_bits + x;
 		if (bi->bi_bh) {
 			brelse(bi->bi_bh);
 			bi->bi_bh = NULL;
 		}
 	}
 }
 int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
 			     struct buffer_head *bh,
 			     const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
 {
 	struct super_block *sb = sdp->sd_vfs;
 	struct block_device *bdev = sb->s_bdev;
 	const unsigned int sects_per_blk = sdp->sd_sb.sb_bsize /
 					   bdev_logical_block_size(sb->s_bdev);
 	u64 blk;
 	sector_t start = 0;
 	sector_t nr_sects = 0;
 	int rv;
 	unsigned int x;
 	u32 trimmed = 0;
 	u8 diff;
 	for (x = 0; x < bi->bi_len; x++) {
 		const u8 *clone = bi->bi_clone ? bi->bi_clone : bi->bi_bh->b_data;
 		clone += bi->bi_offset;
 		clone += x;
 		if (bh) {
 			const u8 *orig = bh->b_data + bi->bi_offset + x;
 			diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));
 		} else {
 			diff = ~(*clone | (*clone >> 1));
 		}
 		diff &= 0x55;
 		if (diff == 0)
 			continue;
 		blk = offset + ((bi->bi_start + x) * GFS2_NBBY);
 		blk *= sects_per_blk; /* convert to sectors */
 		while(diff) {
 			if (diff & 1) {
 				if (nr_sects == 0)
 					goto start_new_extent;
 				if ((start + nr_sects) != blk) {
 					if (nr_sects >= minlen) {
 						rv = blkdev_issue_discard(bdev,
 							start, nr_sects,
 							GFP_NOFS, 0);
 						if (rv)
 							goto fail;
 						trimmed += nr_sects;
 					}
 					nr_sects = 0;
 start_new_extent:
 					start = blk;
 				}
 				nr_sects += sects_per_blk;
 			}
 			diff >>= 2;
 			blk += sects_per_blk;
 		}
 	}
 	if (nr_sects >= minlen) {
 		rv = blkdev_issue_discard(bdev, start, nr_sects, GFP_NOFS, 0);
 		if (rv)
 			goto fail;
 		trimmed += nr_sects;
 	}
 	if (ptrimmed)
 		*ptrimmed = trimmed;
 	return 0;
 fail:
 	if (sdp->sd_args.ar_discard)
 		fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem", rv);
 	sdp->sd_args.ar_discard = 0;
 	return -EIO;
 }
 /**
  * gfs2_fitrim - Generate discard requests for unused bits of the filesystem
  * @filp: Any file on the filesystem
  * @argp: Pointer to the arguments (also used to pass result)
  *
  * Returns: 0 on success, otherwise error code
  */
 int gfs2_fitrim(struct file *filp, void __user *argp)
 {
 	struct inode *inode = filp->f_dentry->d_inode;
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	struct request_queue *q = bdev_get_queue(sdp->sd_vfs->s_bdev);
 	struct buffer_head *bh;
 	struct gfs2_rgrpd *rgd;
 	struct gfs2_rgrpd *rgd_end;
 	struct gfs2_holder gh;
 	struct fstrim_range r;
 	int ret = 0;
 	u64 amt;
 	u64 trimmed = 0;
 	u64 start, end, minlen;
 	unsigned int x;
 	unsigned bs_shift = sdp->sd_sb.sb_bsize_shift;
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
 	if (!blk_queue_discard(q))
 		return -EOPNOTSUPP;
 	if (copy_from_user(&r, argp, sizeof(r)))
 		return -EFAULT;
 	ret = gfs2_rindex_update(sdp);
 	if (ret)
 		return ret;
 	start = r.start >> bs_shift;
 	end = start + (r.len >> bs_shift);
 	minlen = max_t(u64, r.minlen,
 		       q->limits.discard_granularity) >> bs_shift;
 	rgd = gfs2_blk2rgrpd(sdp, start, 0);
 	rgd_end = gfs2_blk2rgrpd(sdp, end - 1, 0);
 	if (end <= start ||
 	    minlen > sdp->sd_max_rg_data ||
 	    start > rgd_end->rd_data0 + rgd_end->rd_data)
 		return -EINVAL;
 	while (1) {
 		ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
 		if (ret)
 			goto out;
 		if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
 			/* Trim each bitmap in the rgrp */
 			for (x = 0; x < rgd->rd_length; x++) {
 				struct gfs2_bitmap *bi = rgd->rd_bits + x;
 				ret = gfs2_rgrp_send_discards(sdp,
 						rgd->rd_data0, NULL, bi, minlen,
 						&amt);
 				if (ret) {
 					gfs2_glock_dq_uninit(&gh);
 					goto out;
 				}
 				trimmed += amt;
 			}
 			/* Mark rgrp as having been trimmed */
 			ret = gfs2_trans_begin(sdp, RES_RG_HDR, 0);
 			if (ret == 0) {
 				bh = rgd->rd_bits[0].bi_bh;
 				rgd->rd_flags |= GFS2_RGF_TRIMMED;
 				gfs2_trans_add_bh(rgd->rd_gl, bh, 1);
 				gfs2_rgrp_out(rgd, bh->b_data);
 				gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, bh->b_data);
 				gfs2_trans_end(sdp);
 			}
 		}
 		gfs2_glock_dq_uninit(&gh);
 		if (rgd == rgd_end)
 			break;
 		rgd = gfs2_rgrpd_get_next(rgd);
 	}
 out:
 	r.len = trimmed << 9;
 	if (copy_to_user(argp, &r, sizeof(r)))
 		return -EFAULT;
 	return ret;
 }
 /**
  * rs_insert - insert a new multi-block reservation into the rgrp's rb_tree
  * @ip: the inode structure
  *
  */
 static void rs_insert(struct gfs2_inode *ip)
 {
 	struct rb_node **newn, *parent = NULL;
 	int rc;
 	struct gfs2_blkreserv *rs = ip->i_res;
 	struct gfs2_rgrpd *rgd = rs->rs_rbm.rgd;
 	u64 fsblock = gfs2_rbm_to_block(&rs->rs_rbm);
 	BUG_ON(gfs2_rs_active(rs));
 	spin_lock(&rgd->rd_rsspin);
 	newn = &rgd->rd_rstree.rb_node;
 	while (*newn) {
 		struct gfs2_blkreserv *cur =
 			rb_entry(*newn, struct gfs2_blkreserv, rs_node);
 		parent = *newn;
 		rc = rs_cmp(fsblock, rs->rs_free, cur);
 		if (rc > 0)
 			newn = &((*newn)->rb_right);
 		else if (rc < 0)
 			newn = &((*newn)->rb_left);
 		else {
 			spin_unlock(&rgd->rd_rsspin);
 			WARN_ON(1);
 			return;
 		}
 	}
 	rb_link_node(&rs->rs_node, parent, newn);
 	rb_insert_color(&rs->rs_node, &rgd->rd_rstree);
 	/* Do our rgrp accounting for the reservation */
 	rgd->rd_reserved += rs->rs_free; /* blocks reserved */
 	spin_unlock(&rgd->rd_rsspin);
 	trace_gfs2_rs(rs, TRACE_RS_INSERT);
 }
 /**
  * rg_mblk_search - find a group of multiple free blocks to form a reservation
  * @rgd: the resource group descriptor
  * @ip: pointer to the inode for which we're reserving blocks
  * @requested: number of blocks required for this allocation
  *
  */
 static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
 			   unsigned requested)
 {
 	struct gfs2_rbm rbm = { .rgd = rgd, };
 	u64 goal;
 	struct gfs2_blkreserv *rs = ip->i_res;
 	u32 extlen;
 	u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
 	int ret;
 	extlen = max_t(u32, atomic_read(&rs->rs_sizehint), requested);
 	extlen = clamp(extlen, RGRP_RSRV_MINBLKS, free_blocks);
 	if ((rgd->rd_free_clone < rgd->rd_reserved) || (free_blocks < extlen))
 		return;
 	/* Find bitmap block that contains bits for goal block */
 	if (rgrp_contains_block(rgd, ip->i_goal))
 		goal = ip->i_goal;
 	else
 		goal = rgd->rd_last_alloc + rgd->rd_data0;
 	if (WARN_ON(gfs2_rbm_from_block(&rbm, goal)))
 		return;
 	ret = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, extlen, ip, true);
 	if (ret == 0) {
 		rs->rs_rbm = rbm;
 		rs->rs_free = extlen;
 		rs->rs_inum = ip->i_no_addr;
 		rs_insert(ip);
 	}
 }
 /**
  * gfs2_next_unreserved_block - Return next block that is not reserved
  * @rgd: The resource group
  * @block: The starting block
  * @length: The required length
  * @ip: Ignore any reservations for this inode
  *
  * If the block does not appear in any reservation, then return the
  * block number unchanged. If it does appear in the reservation, then
  * keep looking through the tree of reservations in order to find the
  * first block number which is not reserved.
  */
 static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
 				      u32 length,
 				      const struct gfs2_inode *ip)
 {
 	struct gfs2_blkreserv *rs;
 	struct rb_node *n;
 	int rc;
 	spin_lock(&rgd->rd_rsspin);
 	n = rgd->rd_rstree.rb_node;
 	while (n) {
 		rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
 		rc = rs_cmp(block, length, rs);
 		if (rc < 0)
 			n = n->rb_left;
 		else if (rc > 0)
 			n = n->rb_right;
 		else
 			break;
 	}
 	if (n) {
 		while ((rs_cmp(block, length, rs) == 0) && (ip->i_res != rs)) {
 			block = gfs2_rbm_to_block(&rs->rs_rbm) + rs->rs_free;
 			n = n->rb_right;
 			if (n == NULL)
 				break;
 			rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
 		}
 	}
 	spin_unlock(&rgd->rd_rsspin);
 	return block;
 }
 /**
  * gfs2_reservation_check_and_update - Check for reservations during block alloc
  * @rbm: The current position in the resource group
  * @ip: The inode for which we are searching for blocks
  * @minext: The minimum extent length
  *
  * This checks the current position in the rgrp to see whether there is
  * a reservation covering this block. If not then this function is a
  * no-op. If there is, then the position is moved to the end of the
  * contiguous reservation(s) so that we are pointing at the first
  * non-reserved block.
  *
  * Returns: 0 if no reservation, 1 if @rbm has changed, otherwise an error
  */
 static int gfs2_reservation_check_and_update(struct gfs2_rbm *rbm,
 					     const struct gfs2_inode *ip,
 					     u32 minext)
 {
 	u64 block = gfs2_rbm_to_block(rbm);
 	u32 extlen = 1;
 	u64 nblock;
 	int ret;
 	/*
 	 * If we have a minimum extent length, then skip over any extent
 	 * which is less than the min extent length in size.
 	 */
 	if (minext) {
 		extlen = gfs2_free_extlen(rbm, minext);
 		nblock = block + extlen;
 		if (extlen < minext)
 			goto fail;
 	}
 	/*
 	 * Check the extent which has been found against the reservations
 	 * and skip if parts of it are already reserved
 	 */
 	nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, ip);
 	if (nblock == block)
 		return 0;
 fail:
 	ret = gfs2_rbm_from_block(rbm, nblock);
 	if (ret < 0)
 		return ret;
 	return 1;
 }
 /**
  * gfs2_rbm_find - Look for blocks of a particular state
  * @rbm: Value/result starting position and final position
  * @state: The state which we want to find
  * @minext: The requested extent length (0 for a single block)
  * @ip: If set, check for reservations
  * @nowrap: Stop looking at the end of the rgrp, rather than wrapping
  *          around until we've reached the starting point.
  *
  * Side effects:
  * - If looking for free blocks, we set GBF_FULL on each bitmap which
  *   has no free blocks in it.
  *
  * Returns: 0 on success, -ENOSPC if there is no block of the requested state
  */
 static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 minext,
 			 const struct gfs2_inode *ip, bool nowrap)
 {
 	struct buffer_head *bh;
 	struct gfs2_bitmap *initial_bi;
 	u32 initial_offset;
 	u32 offset;
 	u8 *buffer;
 	int index;
 	int n = 0;
 	int iters = rbm->rgd->rd_length;
 	int ret;
 	/* If we are not starting at the beginning of a bitmap, then we
 	 * need to add one to the bitmap count to ensure that we search
 	 * the starting bitmap twice.
 	 */
 	if (rbm->offset != 0)
 		iters++;
 	while(1) {
 		if (test_bit(GBF_FULL, &rbm->bi->bi_flags) &&
 		    (state == GFS2_BLKST_FREE))
 			goto next_bitmap;
 		bh = rbm->bi->bi_bh;
 		buffer = bh->b_data + rbm->bi->bi_offset;
 		WARN_ON(!buffer_uptodate(bh));
 		if (state != GFS2_BLKST_UNLINKED && rbm->bi->bi_clone)
 			buffer = rbm->bi->bi_clone + rbm->bi->bi_offset;
 		initial_offset = rbm->offset;
 		offset = gfs2_bitfit(buffer, rbm->bi->bi_len, rbm->offset, state);
 		if (offset == BFITNOENT)
 			goto bitmap_full;
 		rbm->offset = offset;
 		if (ip == NULL)
 			return 0;
 		initial_bi = rbm->bi;
 		ret = gfs2_reservation_check_and_update(rbm, ip, minext);
 		if (ret == 0)
 			return 0;
 		if (ret > 0) {
 			n += (rbm->bi - initial_bi);
 			goto next_iter;
 		}
 		if (ret == -E2BIG) {
 			index = 0;
 			rbm->offset = 0;
 			n += (rbm->bi - initial_bi);
 			goto res_covered_end_of_rgrp;
 		}
 		return ret;
 bitmap_full:	/* Mark bitmap as full and fall through */
 		if ((state == GFS2_BLKST_FREE) && initial_offset == 0)
 			set_bit(GBF_FULL, &rbm->bi->bi_flags);
 next_bitmap:	/* Find next bitmap in the rgrp */
 		rbm->offset = 0;
 		index = rbm->bi - rbm->rgd->rd_bits;
 		index++;
 		if (index == rbm->rgd->rd_length)
 			index = 0;
 res_covered_end_of_rgrp:
 		rbm->bi = &rbm->rgd->rd_bits[index];
 		if ((index == 0) && nowrap)
 			break;
 		n++;
 next_iter:
 		if (n >= iters)
 			break;
 	}
 	return -ENOSPC;
 }
 /**
  * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
  * @rgd: The rgrp
  * @last_unlinked: block address of the last dinode we unlinked
  * @skip: block address we should explicitly not unlink
  *
  * Returns: 0 if no error
  *          The inode, if one has been found, in inode.
  */
 static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
 {
 	u64 block;
 	struct gfs2_sbd *sdp = rgd->rd_sbd;
 	struct gfs2_glock *gl;
 	struct gfs2_inode *ip;
 	int error;
 	int found = 0;
 	struct gfs2_rbm rbm = { .rgd = rgd, .bi = rgd->rd_bits, .offset = 0 };
 	while (1) {
 		down_write(&sdp->sd_log_flush_lock);
 		error = gfs2_rbm_find(&rbm, GFS2_BLKST_UNLINKED, 0, NULL, true);
 		up_write(&sdp->sd_log_flush_lock);
 		if (error == -ENOSPC)
 			break;
 		if (WARN_ON_ONCE(error))
 			break;
 		block = gfs2_rbm_to_block(&rbm);
 		if (gfs2_rbm_from_block(&rbm, block + 1))
 			break;
 		if (*last_unlinked != NO_BLOCK && block <= *last_unlinked)
 			continue;
 		if (block == skip)
 			continue;
 		*last_unlinked = block;
 		error = gfs2_glock_get(sdp, block, &gfs2_inode_glops, CREATE, &gl);
 		if (error)
 			continue;
 		/* If the inode is already in cache, we can ignore it here
 		 * because the existing inode disposal code will deal with
 		 * it when all refs have gone away. Accessing gl_object like
 		 * this is not safe in general. Here it is ok because we do
 		 * not dereference the pointer, and we only need an approx
 		 * answer to whether it is NULL or not.
 		 */
 		ip = gl->gl_object;
 		if (ip || queue_work(gfs2_delete_workqueue, &gl->gl_delete) == 0)
 			gfs2_glock_put(gl);
 		else
 			found++;
 		/* Limit reclaim to sensible number of tasks */
 		if (found > NR_CPUS)
 			return;
 	}
 	rgd->rd_flags &= ~GFS2_RDF_CHECK;
 	return;
 }
 /**
  * gfs2_rgrp_congested - Use stats to figure out whether an rgrp is congested
  * @rgd: The rgrp in question
  * @loops: An indication of how picky we can be (0=very, 1=less so)
  *
  * This function uses the recently added glock statistics in order to
  * figure out whether a parciular resource group is suffering from
  * contention from multiple nodes. This is done purely on the basis
  * of timings, since this is the only data we have to work with and
  * our aim here is to reject a resource group which is highly contended
  * but (very important) not to do this too often in order to ensure that
  * we do not land up introducing fragmentation by changing resource
  * groups when not actually required.
  *
  * The calculation is fairly simple, we want to know whether the SRTTB
  * (i.e. smoothed round trip time for blocking operations) to acquire
  * the lock for this rgrp's glock is significantly greater than the
  * time taken for resource groups on average. We introduce a margin in
  * the form of the variable @var which is computed as the sum of the two
  * respective variences, and multiplied by a factor depending on @loops
  * and whether we have a lot of data to base the decision on. This is
  * then tested against the square difference of the means in order to
  * decide whether the result is statistically significant or not.
  *
  * Returns: A boolean verdict on the congestion status
  */
 static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
 {
 	const struct gfs2_glock *gl = rgd->rd_gl;
 	const struct gfs2_sbd *sdp = gl->gl_sbd;
 	struct gfs2_lkstats *st;
 	s64 r_dcount, l_dcount;
 	s64 r_srttb, l_srttb;
 	s64 srttb_diff;
 	s64 sqr_diff;
 	s64 var;
 	preempt_disable();
 	st = &this_cpu_ptr(sdp->sd_lkstats)->lkstats[LM_TYPE_RGRP];
 	r_srttb = st->stats[GFS2_LKS_SRTTB];
 	r_dcount = st->stats[GFS2_LKS_DCOUNT];
 	var = st->stats[GFS2_LKS_SRTTVARB] +
 	      gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
 	preempt_enable();
 	l_srttb = gl->gl_stats.stats[GFS2_LKS_SRTTB];
 	l_dcount = gl->gl_stats.stats[GFS2_LKS_DCOUNT];
 	if ((l_dcount < 1) || (r_dcount < 1) || (r_srttb == 0))
 		return false;
 	srttb_diff = r_srttb - l_srttb;
 	sqr_diff = srttb_diff * srttb_diff;
 	var *= 2;
 	if (l_dcount < 8 || r_dcount < 8)
 		var *= 2;
 	if (loops == 1)
 		var *= 2;
 	return ((srttb_diff < 0) && (sqr_diff > var));
 }
 /**
  * gfs2_rgrp_used_recently
  * @rs: The block reservation with the rgrp to test
  * @msecs: The time limit in milliseconds
  *
  * Returns: True if the rgrp glock has been used within the time limit
  */
 static bool gfs2_rgrp_used_recently(const struct gfs2_blkreserv *rs,
 				    u64 msecs)
 {
 	u64 tdiff;
 	tdiff = ktime_to_ns(ktime_sub(ktime_get_real(),
                             rs->rs_rbm.rgd->rd_gl->gl_dstamp));
 	return tdiff > (msecs * 1000 * 1000);
 }
+static u32 gfs2_orlov_skip(const struct gfs2_inode *ip)
+{
+	const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
+	u32 skip;
+	get_random_bytes(&skip, sizeof(skip));
+	return skip % sdp->sd_rgrps;
+}
 static bool gfs2_select_rgrp(struct gfs2_rgrpd **pos, const struct gfs2_rgrpd *begin)
 {
 	struct gfs2_rgrpd *rgd = *pos;
 	rgd = gfs2_rgrpd_get_next(rgd);
 	if (rgd == NULL)
 		rgd = gfs2_rgrpd_get_next(NULL);
 	*pos = rgd;
 	if (rgd != begin) /* If we didn't wrap */
 		return true;
 	return false;
 }
 /**
  * gfs2_inplace_reserve - Reserve space in the filesystem
  * @ip: the inode to reserve space for
  * @requested: the number of blocks to be reserved
  *
  * Returns: errno
  */
-int gfs2_inplace_reserve(struct gfs2_inode *ip, u32 requested)
+int gfs2_inplace_reserve(struct gfs2_inode *ip, u32 requested, u32 aflags)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	struct gfs2_rgrpd *begin = NULL;
 	struct gfs2_blkreserv *rs = ip->i_res;
 	int error = 0, rg_locked, flags = 0;
 	u64 last_unlinked = NO_BLOCK;
 	int loops = 0;
+	u32 skip = 0;
 	if (sdp->sd_args.ar_rgrplvb)
 		flags |= GL_SKIP;
 	if (gfs2_assert_warn(sdp, requested))
 		return -EINVAL;
 	if (gfs2_rs_active(rs)) {
 		begin = rs->rs_rbm.rgd;
 		flags = 0; /* Yoda: Do or do not. There is no try */
 	} else if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, ip->i_goal)) {
 		rs->rs_rbm.rgd = begin = ip->i_rgd;
 	} else {
 		rs->rs_rbm.rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
 	}
+	if (S_ISDIR(ip->i_inode.i_mode) && (aflags & GFS2_AF_ORLOV))
+		skip = gfs2_orlov_skip(ip);
 	if (rs->rs_rbm.rgd == NULL)
 		return -EBADSLT;
 	while (loops < 3) {
 		rg_locked = 1;
 		if (!gfs2_glock_is_locked_by_me(rs->rs_rbm.rgd->rd_gl)) {
 			rg_locked = 0;
+			if (skip && skip--)
+				goto next_rgrp;
 			if (!gfs2_rs_active(rs) && (loops < 2) &&
 			     gfs2_rgrp_used_recently(rs, 1000) &&
 			     gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
 				goto next_rgrp;
 			error = gfs2_glock_nq_init(rs->rs_rbm.rgd->rd_gl,
 						   LM_ST_EXCLUSIVE, flags,
 						   &rs->rs_rgd_gh);
 			if (unlikely(error))
 				return error;
 			if (!gfs2_rs_active(rs) && (loops < 2) &&
 			    gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
 				goto skip_rgrp;
 			if (sdp->sd_args.ar_rgrplvb) {
 				error = update_rgrp_lvb(rs->rs_rbm.rgd);
 				if (unlikely(error)) {
 					gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
 					return error;
 				}
 			}
 		}
 		/* Skip unuseable resource groups */
 		if (rs->rs_rbm.rgd->rd_flags & (GFS2_RGF_NOALLOC | GFS2_RDF_ERROR))
 			goto skip_rgrp;
 		if (sdp->sd_args.ar_rgrplvb)
 			gfs2_rgrp_bh_get(rs->rs_rbm.rgd);
 		/* Get a reservation if we don't already have one */
 		if (!gfs2_rs_active(rs))
 			rg_mblk_search(rs->rs_rbm.rgd, ip, requested);
 		/* Skip rgrps when we can't get a reservation on first pass */
 		if (!gfs2_rs_active(rs) && (loops < 1))
 			goto check_rgrp;
 		/* If rgrp has enough free space, use it */
 		if (rs->rs_rbm.rgd->rd_free_clone >= requested) {
 			ip->i_rgd = rs->rs_rbm.rgd;
 			return 0;
 		}
 		/* Drop reservation, if we couldn't use reserved rgrp */
 		if (gfs2_rs_active(rs))
 			gfs2_rs_deltree(ip, rs);
 check_rgrp:
 		/* Check for unlinked inodes which can be reclaimed */
 		if (rs->rs_rbm.rgd->rd_flags & GFS2_RDF_CHECK)
 			try_rgrp_unlink(rs->rs_rbm.rgd, &last_unlinked,
 					ip->i_no_addr);
 skip_rgrp:
 		/* Unlock rgrp if required */
 		if (!rg_locked)
 			gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
 next_rgrp:
 		/* Find the next rgrp, and continue looking */
 		if (gfs2_select_rgrp(&rs->rs_rbm.rgd, begin))
+			continue;
+		if (skip)
 			continue;
 		/* If we've scanned all the rgrps, but found no free blocks
 		 * then this checks for some less likely conditions before
 		 * trying again.
 		 */
 		loops++;
 		/* Check that fs hasn't grown if writing to rindex */
 		if (ip == GFS2_I(sdp->sd_rindex) && !sdp->sd_rindex_uptodate) {
 			error = gfs2_ri_update(ip);
 			if (error)
 				return error;
 		}
 		/* Flushing the log may release space */
 		if (loops == 2)
 			gfs2_log_flush(sdp, NULL);
 	}
 	return -ENOSPC;
 }
 /**
  * gfs2_inplace_release - release an inplace reservation
  * @ip: the inode the reservation was taken out on
  *
  * Release a reservation made by gfs2_inplace_reserve().
  */
 void gfs2_inplace_release(struct gfs2_inode *ip)
 {
 	struct gfs2_blkreserv *rs = ip->i_res;
 	if (rs->rs_rgd_gh.gh_gl)
 		gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
 }
 /**
  * gfs2_get_block_type - Check a block in a RG is of given type
  * @rgd: the resource group holding the block
  * @block: the block number
  *
  * Returns: The block type (GFS2_BLKST_*)
  */
 static unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
 {
 	struct gfs2_rbm rbm = { .rgd = rgd, };
 	int ret;
 	ret = gfs2_rbm_from_block(&rbm, block);
 	WARN_ON_ONCE(ret != 0);
 	return gfs2_testbit(&rbm);
 }
 /**
  * gfs2_alloc_extent - allocate an extent from a given bitmap
  * @rbm: the resource group information
  * @dinode: TRUE if the first block we allocate is for a dinode
  * @n: The extent length (value/result)
  *
  * Add the bitmap buffer to the transaction.
  * Set the found bits to @new_state to change block's allocation state.
  */
 static void gfs2_alloc_extent(const struct gfs2_rbm *rbm, bool dinode,
 			     unsigned int *n)
 {
 	struct gfs2_rbm pos = { .rgd = rbm->rgd, };
 	const unsigned int elen = *n;
 	u64 block;
 	int ret;
 	*n = 1;
 	block = gfs2_rbm_to_block(rbm);
 	gfs2_trans_add_bh(rbm->rgd->rd_gl, rbm->bi->bi_bh, 1);
 	gfs2_setbit(rbm, true, dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
 	block++;
 	while (*n < elen) {
 		ret = gfs2_rbm_from_block(&pos, block);
 		if (ret || gfs2_testbit(&pos) != GFS2_BLKST_FREE)
 			break;
 		gfs2_trans_add_bh(pos.rgd->rd_gl, pos.bi->bi_bh, 1);
 		gfs2_setbit(&pos, true, GFS2_BLKST_USED);
 		(*n)++;
 		block++;
 	}
 }
 /**
  * rgblk_free - Change alloc state of given block(s)
  * @sdp: the filesystem
  * @bstart: the start of a run of blocks to free
  * @blen: the length of the block run (all must lie within ONE RG!)
  * @new_state: GFS2_BLKST_XXX the after-allocation block state
  *
  * Returns:  Resource group containing the block(s)
  */
 static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
 				     u32 blen, unsigned char new_state)
 {
 	struct gfs2_rbm rbm;
 	rbm.rgd = gfs2_blk2rgrpd(sdp, bstart, 1);
 	if (!rbm.rgd) {
 		if (gfs2_consist(sdp))
 			fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);
 		return NULL;
 	}
 	while (blen--) {
 		gfs2_rbm_from_block(&rbm, bstart);
 		bstart++;
 		if (!rbm.bi->bi_clone) {
 			rbm.bi->bi_clone = kmalloc(rbm.bi->bi_bh->b_size,
 						   GFP_NOFS | __GFP_NOFAIL);
 			memcpy(rbm.bi->bi_clone + rbm.bi->bi_offset,
 			       rbm.bi->bi_bh->b_data + rbm.bi->bi_offset,
 			       rbm.bi->bi_len);
 		}
 		gfs2_trans_add_bh(rbm.rgd->rd_gl, rbm.bi->bi_bh, 1);
 		gfs2_setbit(&rbm, false, new_state);
 	}
 	return rbm.rgd;
 }
 /**
  * gfs2_rgrp_dump - print out an rgrp
  * @seq: The iterator
  * @gl: The glock in question
  *
  */
 int gfs2_rgrp_dump(struct seq_file *seq, const struct gfs2_glock *gl)
 {
 	struct gfs2_rgrpd *rgd = gl->gl_object;
 	struct gfs2_blkreserv *trs;
 	const struct rb_node *n;
 	if (rgd == NULL)
 		return 0;
 	gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u r:%u\n",
 		       (unsigned long long)rgd->rd_addr, rgd->rd_flags,
 		       rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
 		       rgd->rd_reserved);
 	spin_lock(&rgd->rd_rsspin);
 	for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
 		trs = rb_entry(n, struct gfs2_blkreserv, rs_node);
 		dump_rs(seq, trs);
 	}
 	spin_unlock(&rgd->rd_rsspin);
 	return 0;
 }
 static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
 {
 	struct gfs2_sbd *sdp = rgd->rd_sbd;
 	fs_warn(sdp, "rgrp %llu has an error, marking it readonly until umount\n",
 		(unsigned long long)rgd->rd_addr);
 	fs_warn(sdp, "umount on all nodes and run fsck.gfs2 to fix the error\n");
 	gfs2_rgrp_dump(NULL, rgd->rd_gl);
 	rgd->rd_flags |= GFS2_RDF_ERROR;
 }
 /**
  * gfs2_adjust_reservation - Adjust (or remove) a reservation after allocation
  * @ip: The inode we have just allocated blocks for
  * @rbm: The start of the allocated blocks
  * @len: The extent length
  *
  * Adjusts a reservation after an allocation has taken place. If the
  * reservation does not match the allocation, or if it is now empty
  * then it is removed.
  */
 static void gfs2_adjust_reservation(struct gfs2_inode *ip,
 				    const struct gfs2_rbm *rbm, unsigned len)
 {
 	struct gfs2_blkreserv *rs = ip->i_res;
 	struct gfs2_rgrpd *rgd = rbm->rgd;
 	unsigned rlen;
 	u64 block;
 	int ret;
 	spin_lock(&rgd->rd_rsspin);
 	if (gfs2_rs_active(rs)) {
 		if (gfs2_rbm_eq(&rs->rs_rbm, rbm)) {
 			block = gfs2_rbm_to_block(rbm);
 			ret = gfs2_rbm_from_block(&rs->rs_rbm, block + len);
 			rlen = min(rs->rs_free, len);
 			rs->rs_free -= rlen;
 			rgd->rd_reserved -= rlen;
 			trace_gfs2_rs(rs, TRACE_RS_CLAIM);
 			if (rs->rs_free && !ret)
 				goto out;
 		}
 		__rs_deltree(ip, rs);
 	}
 out:
 	spin_unlock(&rgd->rd_rsspin);
 }
 /**
  * gfs2_alloc_blocks - Allocate one or more blocks of data and/or a dinode
  * @ip: the inode to allocate the block for
  * @bn: Used to return the starting block number
  * @nblocks: requested number of blocks/extent length (value/result)
  * @dinode: 1 if we're allocating a dinode block, else 0
  * @generation: the generation number of the inode
  *
  * Returns: 0 or error
  */
 int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
 		      bool dinode, u64 *generation)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	struct buffer_head *dibh;
 	struct gfs2_rbm rbm = { .rgd = ip->i_rgd, };
 	unsigned int ndata;
 	u64 goal;
 	u64 block; /* block, within the file system scope */
 	int error;
 	if (gfs2_rs_active(ip->i_res))
 		goal = gfs2_rbm_to_block(&ip->i_res->rs_rbm);
 	else if (!dinode && rgrp_contains_block(rbm.rgd, ip->i_goal))
 		goal = ip->i_goal;
 	else
 		goal = rbm.rgd->rd_last_alloc + rbm.rgd->rd_data0;
 	gfs2_rbm_from_block(&rbm, goal);
 	error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, 0, ip, false);
 	if (error == -ENOSPC) {
 		gfs2_rbm_from_block(&rbm, goal);
 		error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, 0, NULL, false);
 	}
 	/* Since all blocks are reserved in advance, this shouldn't happen */
 	if (error) {
 		fs_warn(sdp, "inum=%llu error=%d, nblocks=%u, full=%d\n",
 			(unsigned long long)ip->i_no_addr, error, *nblocks,
 			test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags));
 		goto rgrp_error;
 	}
 	gfs2_alloc_extent(&rbm, dinode, nblocks);
 	block = gfs2_rbm_to_block(&rbm);
 	rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
 	if (gfs2_rs_active(ip->i_res))
 		gfs2_adjust_reservation(ip, &rbm, *nblocks);
 	ndata = *nblocks;
 	if (dinode)
 		ndata--;
 	if (!dinode) {
 		ip->i_goal = block + ndata - 1;
 		error = gfs2_meta_inode_buffer(ip, &dibh);
 		if (error == 0) {
 			struct gfs2_dinode *di =
 				(struct gfs2_dinode *)dibh->b_data;
 			gfs2_trans_add_bh(ip->i_gl, dibh, 1);
 			di->di_goal_meta = di->di_goal_data =
 				cpu_to_be64(ip->i_goal);
 			brelse(dibh);
 		}
 	}
 	if (rbm.rgd->rd_free < *nblocks) {
 		printk(KERN_WARNING "nblocks=%u\n", *nblocks);
 		goto rgrp_error;
 	}
 	rbm.rgd->rd_free -= *nblocks;
 	if (dinode) {
 		rbm.rgd->rd_dinodes++;
 		*generation = rbm.rgd->rd_igeneration++;
 		if (*generation == 0)
 			*generation = rbm.rgd->rd_igeneration++;
 	}
 	gfs2_trans_add_bh(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh, 1);
 	gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
 	gfs2_rgrp_ondisk2lvb(rbm.rgd->rd_rgl, rbm.rgd->rd_bits[0].bi_bh->b_data);
 	gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
 	if (dinode)
 		gfs2_trans_add_unrevoke(sdp, block, 1);
 	/*
 	 * This needs reviewing to see why we cannot do the quota change
 	 * at this point in the dinode case.
 	 */
 	if (ndata)
 		gfs2_quota_change(ip, ndata, ip->i_inode.i_uid,
 				  ip->i_inode.i_gid);
 	rbm.rgd->rd_free_clone -= *nblocks;
 	trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
 			       dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
 	*bn = block;
 	return 0;
 rgrp_error:
 	gfs2_rgrp_error(rbm.rgd);
 	return -EIO;
 }
 /**
  * __gfs2_free_blocks - free a contiguous run of block(s)
  * @ip: the inode these blocks are being freed from
  * @bstart: first block of a run of contiguous blocks
  * @blen: the length of the block run
  * @meta: 1 if the blocks represent metadata
  *
  */
 void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	struct gfs2_rgrpd *rgd;
 	rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
 	if (!rgd)
 		return;
 	trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
 	rgd->rd_free += blen;
 	rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
 	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
 	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
 	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
 	/* Directories keep their data in the metadata address space */
 	if (meta || ip->i_depth)
 		gfs2_meta_wipe(ip, bstart, blen);
 }
 /**
  * gfs2_free_meta - free a contiguous run of data block(s)
  * @ip: the inode these blocks are being freed from
  * @bstart: first block of a run of contiguous blocks
  * @blen: the length of the block run
  *
  */
 void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	__gfs2_free_blocks(ip, bstart, blen, 1);
 	gfs2_statfs_change(sdp, 0, +blen, 0);
 	gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
 }
 void gfs2_unlink_di(struct inode *inode)
 {
 	struct gfs2_inode *ip = GFS2_I(inode);
 	struct gfs2_sbd *sdp = GFS2_SB(inode);
 	struct gfs2_rgrpd *rgd;
 	u64 blkno = ip->i_no_addr;
 	rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);
 	if (!rgd)
 		return;
 	trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
 	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
 	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
 	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
 	update_rgrp_lvb_unlinked(rgd, 1);
 }
 static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
 {
 	struct gfs2_sbd *sdp = rgd->rd_sbd;
 	struct gfs2_rgrpd *tmp_rgd;
 	tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE);
 	if (!tmp_rgd)
 		return;
 	gfs2_assert_withdraw(sdp, rgd == tmp_rgd);
 	if (!rgd->rd_dinodes)
 		gfs2_consist_rgrpd(rgd);
 	rgd->rd_dinodes--;
 	rgd->rd_free++;
 	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
 	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
 	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
 	update_rgrp_lvb_unlinked(rgd, -1);
 	gfs2_statfs_change(sdp, 0, +1, -1);
 }
 void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
 {
 	gfs2_free_uninit_di(rgd, ip->i_no_addr);
 	trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
 	gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
 	gfs2_meta_wipe(ip, ip->i_no_addr, 1);
 }
 /**
  * gfs2_check_blk_type - Check the type of a block
  * @sdp: The superblock
  * @no_addr: The block number to check
  * @type: The block type we are looking for
  *
  * Returns: 0 if the block type matches the expected type
  *          -ESTALE if it doesn't match
  *          or -ve errno if something went wrong while checking
  */
 int gfs2_check_blk_type(struct gfs2_sbd *sdp, u64 no_addr, unsigned int type)
 {
 	struct gfs2_rgrpd *rgd;
 	struct gfs2_holder rgd_gh;
 	int error = -EINVAL;
 	rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
 	if (!rgd)
 		goto fail;
 	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
 	if (error)
 		goto fail;
 	if (gfs2_get_block_type(rgd, no_addr) != type)
 		error = -ESTALE;
 	gfs2_glock_dq_uninit(&rgd_gh);
 fail:
 	return error;
 }
 /**
  * gfs2_rlist_add - add a RG to a list of RGs
  * @ip: the inode
  * @rlist: the list of resource groups
  * @block: the block
  *
  * Figure out what RG a block belongs to and add that RG to the list
  *
  * FIXME: Don't use NOFAIL
  *
  */
 void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
 		    u64 block)
 {
 	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
 	struct gfs2_rgrpd *rgd;
 	struct gfs2_rgrpd **tmp;
 	unsigned int new_space;
 	unsigned int x;
 	if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
 		return;
 	if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, block))
 		rgd = ip->i_rgd;
 	else
 		rgd = gfs2_blk2rgrpd(sdp, block, 1);
 	if (!rgd) {
 		fs_err(sdp, "rlist_add: no rgrp for block %llu\n", (unsigned long long)block);
 		return;
 	}
 	ip->i_rgd = rgd;
 	for (x = 0; x < rlist->rl_rgrps; x++)
 		if (rlist->rl_rgd[x] == rgd)
 			return;
 	if (rlist->rl_rgrps == rlist->rl_space) {
 		new_space = rlist->rl_space + 10;
 		tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
 			      GFP_NOFS | __GFP_NOFAIL);
 		if (rlist->rl_rgd) {
 			memcpy(tmp, rlist->rl_rgd,
 			       rlist->rl_space * sizeof(struct gfs2_rgrpd *));
 			kfree(rlist->rl_rgd);
 		}
 		rlist->rl_space = new_space;
 		rlist->rl_rgd = tmp;
 	}
 	rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
 }
 /**
  * gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
  *      and initialize an array of glock holders for them
  * @rlist: the list of resource groups
  * @state: the lock state to acquire the RG lock in
  *
  * FIXME: Don't use NOFAIL
  *
  */
 void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state)
 {
 	unsigned int x;
 	rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder),
 				GFP_NOFS | __GFP_NOFAIL);
 	for (x = 0; x < rlist->rl_rgrps; x++)
 		gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
 				state, 0,
 				&rlist->rl_ghs[x]);
 }
 /**
  * gfs2_rlist_free - free a resource group list
  * @list: the list of resource groups
  *
  */
 void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
 {
 	unsigned int x;
 	kfree(rlist->rl_rgd);
 	if (rlist->rl_ghs) {
 		for (x = 0; x < rlist->rl_rgrps; x++)
 			gfs2_holder_uninit(&rlist->rl_ghs[x]);
 		kfree(rlist->rl_ghs);
 		rlist->rl_ghs = NULL;
 	}
 }

fs/gfs2/rgrp.h

Diff comments View file @ 9dbe961

 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  * Copyright (C) 2004-2008 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 version 2.
  */
 #ifndef __RGRP_DOT_H__
 #define __RGRP_DOT_H__
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 /* Since each block in the file system is represented by two bits in the
  * bitmap, one 64-bit word in the bitmap will represent 32 blocks.
  * By reserving 32 blocks at a time, we can optimize / shortcut how we search
  * through the bitmaps by looking a word at a time.
  */
 #define RGRP_RSRV_MINBYTES 8
 #define RGRP_RSRV_MINBLKS ((u32)(RGRP_RSRV_MINBYTES * GFS2_NBBY))
 struct gfs2_rgrpd;
 struct gfs2_sbd;
 struct gfs2_holder;
 extern void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd);
 extern struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact);
 extern struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp);
 extern struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd);
 extern void gfs2_clear_rgrpd(struct gfs2_sbd *sdp);
 extern int gfs2_rindex_update(struct gfs2_sbd *sdp);
 extern void gfs2_free_clones(struct gfs2_rgrpd *rgd);
 extern int gfs2_rgrp_go_lock(struct gfs2_holder *gh);
 extern void gfs2_rgrp_go_unlock(struct gfs2_holder *gh);
 extern struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip);
-extern int gfs2_inplace_reserve(struct gfs2_inode *ip, u32 requested);
+#define GFS2_AF_ORLOV 1
+extern int gfs2_inplace_reserve(struct gfs2_inode *ip, u32 requested, u32 flags);
 extern void gfs2_inplace_release(struct gfs2_inode *ip);
 extern int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *n,
 			     bool dinode, u64 *generation);
 extern int gfs2_rs_alloc(struct gfs2_inode *ip);
 extern void gfs2_rs_deltree(struct gfs2_inode *ip, struct gfs2_blkreserv *rs);
 extern void gfs2_rs_delete(struct gfs2_inode *ip);
 extern void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta);
 extern void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen);
 extern void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip);
 extern void gfs2_unlink_di(struct inode *inode);
 extern int gfs2_check_blk_type(struct gfs2_sbd *sdp, u64 no_addr,
 			       unsigned int type);
 struct gfs2_rgrp_list {
 	unsigned int rl_rgrps;
 	unsigned int rl_space;
 	struct gfs2_rgrpd **rl_rgd;
 	struct gfs2_holder *rl_ghs;
 };
 extern void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
 			   u64 block);
 extern void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state);
 extern void gfs2_rlist_free(struct gfs2_rgrp_list *rlist);
 extern u64 gfs2_ri_total(struct gfs2_sbd *sdp);
 extern int gfs2_rgrp_dump(struct seq_file *seq, const struct gfs2_glock *gl);
 extern int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
 				   struct buffer_head *bh,
 				   const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed);
 extern int gfs2_fitrim(struct file *filp, void __user *argp);
 /* This is how to tell if a reservation is in the rgrp tree: */
 static inline bool gfs2_rs_active(struct gfs2_blkreserv *rs)
 {
 	return rs && !RB_EMPTY_NODE(&rs->rs_node);
 }
 #endif /* __RGRP_DOT_H__ */

fs/gfs2/xattr.c

Diff comments View file @ 9dbe961

1	/*	1	/*
2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.	3	* Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
4	*	4	*
5	* This copyrighted material is made available to anyone wishing to use,	5	* This copyrighted material is made available to anyone wishing to use,
6	* modify, copy, or redistribute it subject to the terms and conditions	6	* modify, copy, or redistribute it subject to the terms and conditions
7	* of the GNU General Public License version 2.	7	* of the GNU General Public License version 2.
8	*/	8	*/
9		9
10	#include <linux/slab.h>	10	#include <linux/slab.h>
11	#include <linux/spinlock.h>	11	#include <linux/spinlock.h>
12	#include <linux/completion.h>	12	#include <linux/completion.h>
13	#include <linux/buffer_head.h>	13	#include <linux/buffer_head.h>
14	#include <linux/xattr.h>	14	#include <linux/xattr.h>
15	#include <linux/gfs2_ondisk.h>	15	#include <linux/gfs2_ondisk.h>
16	#include <asm/uaccess.h>	16	#include <asm/uaccess.h>
17		17
18	#include "gfs2.h"	18	#include "gfs2.h"
19	#include "incore.h"	19	#include "incore.h"
20	#include "acl.h"	20	#include "acl.h"
21	#include "xattr.h"	21	#include "xattr.h"
22	#include "glock.h"	22	#include "glock.h"
23	#include "inode.h"	23	#include "inode.h"
24	#include "meta_io.h"	24	#include "meta_io.h"
25	#include "quota.h"	25	#include "quota.h"
26	#include "rgrp.h"	26	#include "rgrp.h"
27	#include "trans.h"	27	#include "trans.h"
28	#include "util.h"	28	#include "util.h"
29		29
30	/**	30	/**
31	* ea_calc_size - returns the acutal number of bytes the request will take up	31	* ea_calc_size - returns the acutal number of bytes the request will take up
32	* (not counting any unstuffed data blocks)	32	* (not counting any unstuffed data blocks)
33	* @sdp:	33	* @sdp:
34	* @er:	34	* @er:
35	* @size:	35	* @size:
36	*	36	*
37	* Returns: 1 if the EA should be stuffed	37	* Returns: 1 if the EA should be stuffed
38	*/	38	*/
39		39
40	static int ea_calc_size(struct gfs2_sbd *sdp, unsigned int nsize, size_t dsize,	40	static int ea_calc_size(struct gfs2_sbd *sdp, unsigned int nsize, size_t dsize,
41	unsigned int *size)	41	unsigned int *size)
42	{	42	{
43	unsigned int jbsize = sdp->sd_jbsize;	43	unsigned int jbsize = sdp->sd_jbsize;
44		44
45	/* Stuffed */	45	/* Stuffed */
46	*size = ALIGN(sizeof(struct gfs2_ea_header) + nsize + dsize, 8);	46	*size = ALIGN(sizeof(struct gfs2_ea_header) + nsize + dsize, 8);
47		47
48	if (*size <= jbsize)	48	if (*size <= jbsize)
49	return 1;	49	return 1;
50		50
51	/* Unstuffed */	51	/* Unstuffed */
52	*size = ALIGN(sizeof(struct gfs2_ea_header) + nsize +	52	*size = ALIGN(sizeof(struct gfs2_ea_header) + nsize +
53	(sizeof(__be64) * DIV_ROUND_UP(dsize, jbsize)), 8);	53	(sizeof(__be64) * DIV_ROUND_UP(dsize, jbsize)), 8);
54		54
55	return 0;	55	return 0;
56	}	56	}
57		57
58	static int ea_check_size(struct gfs2_sbd *sdp, unsigned int nsize, size_t dsize)	58	static int ea_check_size(struct gfs2_sbd *sdp, unsigned int nsize, size_t dsize)
59	{	59	{
60	unsigned int size;	60	unsigned int size;
61		61
62	if (dsize > GFS2_EA_MAX_DATA_LEN)	62	if (dsize > GFS2_EA_MAX_DATA_LEN)
63	return -ERANGE;	63	return -ERANGE;
64		64
65	ea_calc_size(sdp, nsize, dsize, &size);	65	ea_calc_size(sdp, nsize, dsize, &size);
66		66
67	/* This can only happen with 512 byte blocks */	67	/* This can only happen with 512 byte blocks */
68	if (size > sdp->sd_jbsize)	68	if (size > sdp->sd_jbsize)
69	return -ERANGE;	69	return -ERANGE;
70		70
71	return 0;	71	return 0;
72	}	72	}
73		73
74	typedef int (ea_call_t) (struct gfs2_inode ip, struct buffer_head *bh,	74	typedef int (ea_call_t) (struct gfs2_inode ip, struct buffer_head *bh,
75	struct gfs2_ea_header *ea,	75	struct gfs2_ea_header *ea,
76	struct gfs2_ea_header prev, void private);	76	struct gfs2_ea_header prev, void private);
77		77
78	static int ea_foreach_i(struct gfs2_inode ip, struct buffer_head bh,	78	static int ea_foreach_i(struct gfs2_inode ip, struct buffer_head bh,
79	ea_call_t ea_call, void *data)	79	ea_call_t ea_call, void *data)
80	{	80	{
81	struct gfs2_ea_header ea, prev = NULL;	81	struct gfs2_ea_header ea, prev = NULL;
82	int error = 0;	82	int error = 0;
83		83
84	if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_EA))	84	if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_EA))
85	return -EIO;	85	return -EIO;
86		86
87	for (ea = GFS2_EA_BH2FIRST(bh);; prev = ea, ea = GFS2_EA2NEXT(ea)) {	87	for (ea = GFS2_EA_BH2FIRST(bh);; prev = ea, ea = GFS2_EA2NEXT(ea)) {
88	if (!GFS2_EA_REC_LEN(ea))	88	if (!GFS2_EA_REC_LEN(ea))
89	goto fail;	89	goto fail;
90	if (!(bh->b_data <= (char )ea && (char )GFS2_EA2NEXT(ea) <=	90	if (!(bh->b_data <= (char )ea && (char )GFS2_EA2NEXT(ea) <=
91	bh->b_data + bh->b_size))	91	bh->b_data + bh->b_size))
92	goto fail;	92	goto fail;
93	if (!GFS2_EATYPE_VALID(ea->ea_type))	93	if (!GFS2_EATYPE_VALID(ea->ea_type))
94	goto fail;	94	goto fail;
95		95
96	error = ea_call(ip, bh, ea, prev, data);	96	error = ea_call(ip, bh, ea, prev, data);
97	if (error)	97	if (error)
98	return error;	98	return error;
99		99
100	if (GFS2_EA_IS_LAST(ea)) {	100	if (GFS2_EA_IS_LAST(ea)) {
101	if ((char *)GFS2_EA2NEXT(ea) !=	101	if ((char *)GFS2_EA2NEXT(ea) !=
102	bh->b_data + bh->b_size)	102	bh->b_data + bh->b_size)
103	goto fail;	103	goto fail;
104	break;	104	break;
105	}	105	}
106	}	106	}
107		107
108	return error;	108	return error;
109		109
110	fail:	110	fail:
111	gfs2_consist_inode(ip);	111	gfs2_consist_inode(ip);
112	return -EIO;	112	return -EIO;
113	}	113	}
114		114
115	static int ea_foreach(struct gfs2_inode ip, ea_call_t ea_call, void data)	115	static int ea_foreach(struct gfs2_inode ip, ea_call_t ea_call, void data)
116	{	116	{
117	struct buffer_head bh, eabh;	117	struct buffer_head bh, eabh;
118	__be64 eablk, end;	118	__be64 eablk, end;
119	int error;	119	int error;
120		120
121	error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &bh);	121	error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &bh);
122	if (error)	122	if (error)
123	return error;	123	return error;
124		124
125	if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT)) {	125	if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT)) {
126	error = ea_foreach_i(ip, bh, ea_call, data);	126	error = ea_foreach_i(ip, bh, ea_call, data);
127	goto out;	127	goto out;
128	}	128	}
129		129
130	if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_IN)) {	130	if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_IN)) {
131	error = -EIO;	131	error = -EIO;
132	goto out;	132	goto out;
133	}	133	}
134		134
135	eablk = (__be64 *)(bh->b_data + sizeof(struct gfs2_meta_header));	135	eablk = (__be64 *)(bh->b_data + sizeof(struct gfs2_meta_header));
136	end = eablk + GFS2_SB(&ip->i_inode)->sd_inptrs;	136	end = eablk + GFS2_SB(&ip->i_inode)->sd_inptrs;
137		137
138	for (; eablk < end; eablk++) {	138	for (; eablk < end; eablk++) {
139	u64 bn;	139	u64 bn;
140		140
141	if (!*eablk)	141	if (!*eablk)
142	break;	142	break;
143	bn = be64_to_cpu(*eablk);	143	bn = be64_to_cpu(*eablk);
144		144
145	error = gfs2_meta_read(ip->i_gl, bn, DIO_WAIT, &eabh);	145	error = gfs2_meta_read(ip->i_gl, bn, DIO_WAIT, &eabh);
146	if (error)	146	if (error)
147	break;	147	break;
148	error = ea_foreach_i(ip, eabh, ea_call, data);	148	error = ea_foreach_i(ip, eabh, ea_call, data);
149	brelse(eabh);	149	brelse(eabh);
150	if (error)	150	if (error)
151	break;	151	break;
152	}	152	}
153	out:	153	out:
154	brelse(bh);	154	brelse(bh);
155	return error;	155	return error;
156	}	156	}
157		157
158	struct ea_find {	158	struct ea_find {
159	int type;	159	int type;
160	const char *name;	160	const char *name;
161	size_t namel;	161	size_t namel;
162	struct gfs2_ea_location *ef_el;	162	struct gfs2_ea_location *ef_el;
163	};	163	};
164		164
165	static int ea_find_i(struct gfs2_inode ip, struct buffer_head bh,	165	static int ea_find_i(struct gfs2_inode ip, struct buffer_head bh,
166	struct gfs2_ea_header ea, struct gfs2_ea_header prev,	166	struct gfs2_ea_header ea, struct gfs2_ea_header prev,
167	void *private)	167	void *private)
168	{	168	{
169	struct ea_find *ef = private;	169	struct ea_find *ef = private;
170		170
171	if (ea->ea_type == GFS2_EATYPE_UNUSED)	171	if (ea->ea_type == GFS2_EATYPE_UNUSED)
172	return 0;	172	return 0;
173		173
174	if (ea->ea_type == ef->type) {	174	if (ea->ea_type == ef->type) {
175	if (ea->ea_name_len == ef->namel &&	175	if (ea->ea_name_len == ef->namel &&
176	!memcmp(GFS2_EA2NAME(ea), ef->name, ea->ea_name_len)) {	176	!memcmp(GFS2_EA2NAME(ea), ef->name, ea->ea_name_len)) {
177	struct gfs2_ea_location *el = ef->ef_el;	177	struct gfs2_ea_location *el = ef->ef_el;
178	get_bh(bh);	178	get_bh(bh);
179	el->el_bh = bh;	179	el->el_bh = bh;
180	el->el_ea = ea;	180	el->el_ea = ea;
181	el->el_prev = prev;	181	el->el_prev = prev;
182	return 1;	182	return 1;
183	}	183	}
184	}	184	}
185		185
186	return 0;	186	return 0;
187	}	187	}
188		188
189	static int gfs2_ea_find(struct gfs2_inode ip, int type, const char name,	189	static int gfs2_ea_find(struct gfs2_inode ip, int type, const char name,
190	struct gfs2_ea_location *el)	190	struct gfs2_ea_location *el)
191	{	191	{
192	struct ea_find ef;	192	struct ea_find ef;
193	int error;	193	int error;
194		194
195	ef.type = type;	195	ef.type = type;
196	ef.name = name;	196	ef.name = name;
197	ef.namel = strlen(name);	197	ef.namel = strlen(name);
198	ef.ef_el = el;	198	ef.ef_el = el;
199		199
200	memset(el, 0, sizeof(struct gfs2_ea_location));	200	memset(el, 0, sizeof(struct gfs2_ea_location));
201		201
202	error = ea_foreach(ip, ea_find_i, &ef);	202	error = ea_foreach(ip, ea_find_i, &ef);
203	if (error > 0)	203	if (error > 0)
204	return 0;	204	return 0;
205		205
206	return error;	206	return error;
207	}	207	}
208		208
209	/**	209	/**
210	* ea_dealloc_unstuffed -	210	* ea_dealloc_unstuffed -
211	* @ip:	211	* @ip:
212	* @bh:	212	* @bh:
213	* @ea:	213	* @ea:
214	* @prev:	214	* @prev:
215	* @private:	215	* @private:
216	*	216	*
217	* Take advantage of the fact that all unstuffed blocks are	217	* Take advantage of the fact that all unstuffed blocks are
218	* allocated from the same RG. But watch, this may not always	218	* allocated from the same RG. But watch, this may not always
219	* be true.	219	* be true.
220	*	220	*
221	* Returns: errno	221	* Returns: errno
222	*/	222	*/
223		223
224	static int ea_dealloc_unstuffed(struct gfs2_inode ip, struct buffer_head bh,	224	static int ea_dealloc_unstuffed(struct gfs2_inode ip, struct buffer_head bh,
225	struct gfs2_ea_header *ea,	225	struct gfs2_ea_header *ea,
226	struct gfs2_ea_header prev, void private)	226	struct gfs2_ea_header prev, void private)
227	{	227	{
228	int *leave = private;	228	int *leave = private;
229	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	229	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
230	struct gfs2_rgrpd *rgd;	230	struct gfs2_rgrpd *rgd;
231	struct gfs2_holder rg_gh;	231	struct gfs2_holder rg_gh;
232	struct buffer_head *dibh;	232	struct buffer_head *dibh;
233	__be64 *dataptrs;	233	__be64 *dataptrs;
234	u64 bn = 0;	234	u64 bn = 0;
235	u64 bstart = 0;	235	u64 bstart = 0;
236	unsigned int blen = 0;	236	unsigned int blen = 0;
237	unsigned int blks = 0;	237	unsigned int blks = 0;
238	unsigned int x;	238	unsigned int x;
239	int error;	239	int error;
240		240
241	error = gfs2_rindex_update(sdp);	241	error = gfs2_rindex_update(sdp);
242	if (error)	242	if (error)
243	return error;	243	return error;
244		244
245	if (GFS2_EA_IS_STUFFED(ea))	245	if (GFS2_EA_IS_STUFFED(ea))
246	return 0;	246	return 0;
247		247
248	dataptrs = GFS2_EA2DATAPTRS(ea);	248	dataptrs = GFS2_EA2DATAPTRS(ea);
249	for (x = 0; x < ea->ea_num_ptrs; x++, dataptrs++) {	249	for (x = 0; x < ea->ea_num_ptrs; x++, dataptrs++) {
250	if (*dataptrs) {	250	if (*dataptrs) {
251	blks++;	251	blks++;
252	bn = be64_to_cpu(*dataptrs);	252	bn = be64_to_cpu(*dataptrs);
253	}	253	}
254	}	254	}
255	if (!blks)	255	if (!blks)
256	return 0;	256	return 0;
257		257
258	rgd = gfs2_blk2rgrpd(sdp, bn, 1);	258	rgd = gfs2_blk2rgrpd(sdp, bn, 1);
259	if (!rgd) {	259	if (!rgd) {
260	gfs2_consist_inode(ip);	260	gfs2_consist_inode(ip);
261	return -EIO;	261	return -EIO;
262	}	262	}
263		263
264	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &rg_gh);	264	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &rg_gh);
265	if (error)	265	if (error)
266	return error;	266	return error;
267		267
268	error = gfs2_trans_begin(sdp, rgd->rd_length + RES_DINODE +	268	error = gfs2_trans_begin(sdp, rgd->rd_length + RES_DINODE +
269	RES_EATTR + RES_STATFS + RES_QUOTA, blks);	269	RES_EATTR + RES_STATFS + RES_QUOTA, blks);
270	if (error)	270	if (error)
271	goto out_gunlock;	271	goto out_gunlock;
272		272
273	gfs2_trans_add_bh(ip->i_gl, bh, 1);	273	gfs2_trans_add_bh(ip->i_gl, bh, 1);
274		274
275	dataptrs = GFS2_EA2DATAPTRS(ea);	275	dataptrs = GFS2_EA2DATAPTRS(ea);
276	for (x = 0; x < ea->ea_num_ptrs; x++, dataptrs++) {	276	for (x = 0; x < ea->ea_num_ptrs; x++, dataptrs++) {
277	if (!*dataptrs)	277	if (!*dataptrs)
278	break;	278	break;
279	bn = be64_to_cpu(*dataptrs);	279	bn = be64_to_cpu(*dataptrs);
280		280
281	if (bstart + blen == bn)	281	if (bstart + blen == bn)
282	blen++;	282	blen++;
283	else {	283	else {
284	if (bstart)	284	if (bstart)
285	gfs2_free_meta(ip, bstart, blen);	285	gfs2_free_meta(ip, bstart, blen);
286	bstart = bn;	286	bstart = bn;
287	blen = 1;	287	blen = 1;
288	}	288	}
289		289
290	*dataptrs = 0;	290	*dataptrs = 0;
291	gfs2_add_inode_blocks(&ip->i_inode, -1);	291	gfs2_add_inode_blocks(&ip->i_inode, -1);
292	}	292	}
293	if (bstart)	293	if (bstart)
294	gfs2_free_meta(ip, bstart, blen);	294	gfs2_free_meta(ip, bstart, blen);
295		295
296	if (prev && !leave) {	296	if (prev && !leave) {
297	u32 len;	297	u32 len;
298		298
299	len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);	299	len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
300	prev->ea_rec_len = cpu_to_be32(len);	300	prev->ea_rec_len = cpu_to_be32(len);
301		301
302	if (GFS2_EA_IS_LAST(ea))	302	if (GFS2_EA_IS_LAST(ea))
303	prev->ea_flags \|= GFS2_EAFLAG_LAST;	303	prev->ea_flags \|= GFS2_EAFLAG_LAST;
304	} else {	304	} else {
305	ea->ea_type = GFS2_EATYPE_UNUSED;	305	ea->ea_type = GFS2_EATYPE_UNUSED;
306	ea->ea_num_ptrs = 0;	306	ea->ea_num_ptrs = 0;
307	}	307	}
308		308
309	error = gfs2_meta_inode_buffer(ip, &dibh);	309	error = gfs2_meta_inode_buffer(ip, &dibh);
310	if (!error) {	310	if (!error) {
311	ip->i_inode.i_ctime = CURRENT_TIME;	311	ip->i_inode.i_ctime = CURRENT_TIME;
312	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	312	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
313	gfs2_dinode_out(ip, dibh->b_data);	313	gfs2_dinode_out(ip, dibh->b_data);
314	brelse(dibh);	314	brelse(dibh);
315	}	315	}
316		316
317	gfs2_trans_end(sdp);	317	gfs2_trans_end(sdp);
318		318
319	out_gunlock:	319	out_gunlock:
320	gfs2_glock_dq_uninit(&rg_gh);	320	gfs2_glock_dq_uninit(&rg_gh);
321	return error;	321	return error;
322	}	322	}
323		323
324	static int ea_remove_unstuffed(struct gfs2_inode ip, struct buffer_head bh,	324	static int ea_remove_unstuffed(struct gfs2_inode ip, struct buffer_head bh,
325	struct gfs2_ea_header *ea,	325	struct gfs2_ea_header *ea,
326	struct gfs2_ea_header *prev, int leave)	326	struct gfs2_ea_header *prev, int leave)
327	{	327	{
328	int error;	328	int error;
329		329
330	error = gfs2_rindex_update(GFS2_SB(&ip->i_inode));	330	error = gfs2_rindex_update(GFS2_SB(&ip->i_inode));
331	if (error)	331	if (error)
332	return error;	332	return error;
333		333
334	error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);	334	error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
335	if (error)	335	if (error)
336	goto out_alloc;	336	goto out_alloc;
337		337
338	error = ea_dealloc_unstuffed(ip, bh, ea, prev, (leave) ? &error : NULL);	338	error = ea_dealloc_unstuffed(ip, bh, ea, prev, (leave) ? &error : NULL);
339		339
340	gfs2_quota_unhold(ip);	340	gfs2_quota_unhold(ip);
341	out_alloc:	341	out_alloc:
342	return error;	342	return error;
343	}	343	}
344		344
345	struct ea_list {	345	struct ea_list {
346	struct gfs2_ea_request *ei_er;	346	struct gfs2_ea_request *ei_er;
347	unsigned int ei_size;	347	unsigned int ei_size;
348	};	348	};
349		349
350	static inline unsigned int gfs2_ea_strlen(struct gfs2_ea_header *ea)	350	static inline unsigned int gfs2_ea_strlen(struct gfs2_ea_header *ea)
351	{	351	{
352	switch (ea->ea_type) {	352	switch (ea->ea_type) {
353	case GFS2_EATYPE_USR:	353	case GFS2_EATYPE_USR:
354	return 5 + ea->ea_name_len + 1;	354	return 5 + ea->ea_name_len + 1;
355	case GFS2_EATYPE_SYS:	355	case GFS2_EATYPE_SYS:
356	return 7 + ea->ea_name_len + 1;	356	return 7 + ea->ea_name_len + 1;
357	case GFS2_EATYPE_SECURITY:	357	case GFS2_EATYPE_SECURITY:
358	return 9 + ea->ea_name_len + 1;	358	return 9 + ea->ea_name_len + 1;
359	default:	359	default:
360	return 0;	360	return 0;
361	}	361	}
362	}	362	}
363		363
364	static int ea_list_i(struct gfs2_inode ip, struct buffer_head bh,	364	static int ea_list_i(struct gfs2_inode ip, struct buffer_head bh,
365	struct gfs2_ea_header ea, struct gfs2_ea_header prev,	365	struct gfs2_ea_header ea, struct gfs2_ea_header prev,
366	void *private)	366	void *private)
367	{	367	{
368	struct ea_list *ei = private;	368	struct ea_list *ei = private;
369	struct gfs2_ea_request *er = ei->ei_er;	369	struct gfs2_ea_request *er = ei->ei_er;
370	unsigned int ea_size = gfs2_ea_strlen(ea);	370	unsigned int ea_size = gfs2_ea_strlen(ea);
371		371
372	if (ea->ea_type == GFS2_EATYPE_UNUSED)	372	if (ea->ea_type == GFS2_EATYPE_UNUSED)
373	return 0;	373	return 0;
374		374
375	if (er->er_data_len) {	375	if (er->er_data_len) {
376	char *prefix = NULL;	376	char *prefix = NULL;
377	unsigned int l = 0;	377	unsigned int l = 0;
378	char c = 0;	378	char c = 0;
379		379
380	if (ei->ei_size + ea_size > er->er_data_len)	380	if (ei->ei_size + ea_size > er->er_data_len)
381	return -ERANGE;	381	return -ERANGE;
382		382
383	switch (ea->ea_type) {	383	switch (ea->ea_type) {
384	case GFS2_EATYPE_USR:	384	case GFS2_EATYPE_USR:
385	prefix = "user.";	385	prefix = "user.";
386	l = 5;	386	l = 5;
387	break;	387	break;
388	case GFS2_EATYPE_SYS:	388	case GFS2_EATYPE_SYS:
389	prefix = "system.";	389	prefix = "system.";
390	l = 7;	390	l = 7;
391	break;	391	break;
392	case GFS2_EATYPE_SECURITY:	392	case GFS2_EATYPE_SECURITY:
393	prefix = "security.";	393	prefix = "security.";
394	l = 9;	394	l = 9;
395	break;	395	break;
396	}	396	}
397		397
398	BUG_ON(l == 0);	398	BUG_ON(l == 0);
399		399
400	memcpy(er->er_data + ei->ei_size, prefix, l);	400	memcpy(er->er_data + ei->ei_size, prefix, l);
401	memcpy(er->er_data + ei->ei_size + l, GFS2_EA2NAME(ea),	401	memcpy(er->er_data + ei->ei_size + l, GFS2_EA2NAME(ea),
402	ea->ea_name_len);	402	ea->ea_name_len);
403	memcpy(er->er_data + ei->ei_size + ea_size - 1, &c, 1);	403	memcpy(er->er_data + ei->ei_size + ea_size - 1, &c, 1);
404	}	404	}
405		405
406	ei->ei_size += ea_size;	406	ei->ei_size += ea_size;
407		407
408	return 0;	408	return 0;
409	}	409	}
410		410
411	/**	411	/**
412	* gfs2_listxattr - List gfs2 extended attributes	412	* gfs2_listxattr - List gfs2 extended attributes
413	* @dentry: The dentry whose inode we are interested in	413	* @dentry: The dentry whose inode we are interested in
414	* @buffer: The buffer to write the results	414	* @buffer: The buffer to write the results
415	* @size: The size of the buffer	415	* @size: The size of the buffer
416	*	416	*
417	* Returns: actual size of data on success, -errno on error	417	* Returns: actual size of data on success, -errno on error
418	*/	418	*/
419		419
420	ssize_t gfs2_listxattr(struct dentry dentry, char buffer, size_t size)	420	ssize_t gfs2_listxattr(struct dentry dentry, char buffer, size_t size)
421	{	421	{
422	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);	422	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
423	struct gfs2_ea_request er;	423	struct gfs2_ea_request er;
424	struct gfs2_holder i_gh;	424	struct gfs2_holder i_gh;
425	int error;	425	int error;
426		426
427	memset(&er, 0, sizeof(struct gfs2_ea_request));	427	memset(&er, 0, sizeof(struct gfs2_ea_request));
428	if (size) {	428	if (size) {
429	er.er_data = buffer;	429	er.er_data = buffer;
430	er.er_data_len = size;	430	er.er_data_len = size;
431	}	431	}
432		432
433	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);	433	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
434	if (error)	434	if (error)
435	return error;	435	return error;
436		436
437	if (ip->i_eattr) {	437	if (ip->i_eattr) {
438	struct ea_list ei = { .ei_er = &er, .ei_size = 0 };	438	struct ea_list ei = { .ei_er = &er, .ei_size = 0 };
439		439
440	error = ea_foreach(ip, ea_list_i, &ei);	440	error = ea_foreach(ip, ea_list_i, &ei);
441	if (!error)	441	if (!error)
442	error = ei.ei_size;	442	error = ei.ei_size;
443	}	443	}
444		444
445	gfs2_glock_dq_uninit(&i_gh);	445	gfs2_glock_dq_uninit(&i_gh);
446		446
447	return error;	447	return error;
448	}	448	}
449		449
450	/**	450	/**
451	* ea_iter_unstuffed - copies the unstuffed xattr data to/from the	451	* ea_iter_unstuffed - copies the unstuffed xattr data to/from the
452	* request buffer	452	* request buffer
453	* @ip: The GFS2 inode	453	* @ip: The GFS2 inode
454	* @ea: The extended attribute header structure	454	* @ea: The extended attribute header structure
455	* @din: The data to be copied in	455	* @din: The data to be copied in
456	* @dout: The data to be copied out (one of din,dout will be NULL)	456	* @dout: The data to be copied out (one of din,dout will be NULL)
457	*	457	*
458	* Returns: errno	458	* Returns: errno
459	*/	459	*/
460		460
461	static int gfs2_iter_unstuffed(struct gfs2_inode ip, struct gfs2_ea_header ea,	461	static int gfs2_iter_unstuffed(struct gfs2_inode ip, struct gfs2_ea_header ea,
462	const char din, char dout)	462	const char din, char dout)
463	{	463	{
464	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	464	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
465	struct buffer_head **bh;	465	struct buffer_head **bh;
466	unsigned int amount = GFS2_EA_DATA_LEN(ea);	466	unsigned int amount = GFS2_EA_DATA_LEN(ea);
467	unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);	467	unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);
468	__be64 *dataptrs = GFS2_EA2DATAPTRS(ea);	468	__be64 *dataptrs = GFS2_EA2DATAPTRS(ea);
469	unsigned int x;	469	unsigned int x;
470	int error = 0;	470	int error = 0;
471	unsigned char *pos;	471	unsigned char *pos;
472	unsigned cp_size;	472	unsigned cp_size;
473		473
474	bh = kcalloc(nptrs, sizeof(struct buffer_head *), GFP_NOFS);	474	bh = kcalloc(nptrs, sizeof(struct buffer_head *), GFP_NOFS);
475	if (!bh)	475	if (!bh)
476	return -ENOMEM;	476	return -ENOMEM;
477		477
478	for (x = 0; x < nptrs; x++) {	478	for (x = 0; x < nptrs; x++) {
479	error = gfs2_meta_read(ip->i_gl, be64_to_cpu(*dataptrs), 0,	479	error = gfs2_meta_read(ip->i_gl, be64_to_cpu(*dataptrs), 0,
480	bh + x);	480	bh + x);
481	if (error) {	481	if (error) {
482	while (x--)	482	while (x--)
483	brelse(bh[x]);	483	brelse(bh[x]);
484	goto out;	484	goto out;
485	}	485	}
486	dataptrs++;	486	dataptrs++;
487	}	487	}
488		488
489	for (x = 0; x < nptrs; x++) {	489	for (x = 0; x < nptrs; x++) {
490	error = gfs2_meta_wait(sdp, bh[x]);	490	error = gfs2_meta_wait(sdp, bh[x]);
491	if (error) {	491	if (error) {
492	for (; x < nptrs; x++)	492	for (; x < nptrs; x++)
493	brelse(bh[x]);	493	brelse(bh[x]);
494	goto out;	494	goto out;
495	}	495	}
496	if (gfs2_metatype_check(sdp, bh[x], GFS2_METATYPE_ED)) {	496	if (gfs2_metatype_check(sdp, bh[x], GFS2_METATYPE_ED)) {
497	for (; x < nptrs; x++)	497	for (; x < nptrs; x++)
498	brelse(bh[x]);	498	brelse(bh[x]);
499	error = -EIO;	499	error = -EIO;
500	goto out;	500	goto out;
501	}	501	}
502		502
503	pos = bh[x]->b_data + sizeof(struct gfs2_meta_header);	503	pos = bh[x]->b_data + sizeof(struct gfs2_meta_header);
504	cp_size = (sdp->sd_jbsize > amount) ? amount : sdp->sd_jbsize;	504	cp_size = (sdp->sd_jbsize > amount) ? amount : sdp->sd_jbsize;
505		505
506	if (dout) {	506	if (dout) {
507	memcpy(dout, pos, cp_size);	507	memcpy(dout, pos, cp_size);
508	dout += sdp->sd_jbsize;	508	dout += sdp->sd_jbsize;
509	}	509	}
510		510
511	if (din) {	511	if (din) {
512	gfs2_trans_add_bh(ip->i_gl, bh[x], 1);	512	gfs2_trans_add_bh(ip->i_gl, bh[x], 1);
513	memcpy(pos, din, cp_size);	513	memcpy(pos, din, cp_size);
514	din += sdp->sd_jbsize;	514	din += sdp->sd_jbsize;
515	}	515	}
516		516
517	amount -= sdp->sd_jbsize;	517	amount -= sdp->sd_jbsize;
518	brelse(bh[x]);	518	brelse(bh[x]);
519	}	519	}
520		520
521	out:	521	out:
522	kfree(bh);	522	kfree(bh);
523	return error;	523	return error;
524	}	524	}
525		525
526	static int gfs2_ea_get_copy(struct gfs2_inode ip, struct gfs2_ea_location el,	526	static int gfs2_ea_get_copy(struct gfs2_inode ip, struct gfs2_ea_location el,
527	char *data, size_t size)	527	char *data, size_t size)
528	{	528	{
529	int ret;	529	int ret;
530	size_t len = GFS2_EA_DATA_LEN(el->el_ea);	530	size_t len = GFS2_EA_DATA_LEN(el->el_ea);
531	if (len > size)	531	if (len > size)
532	return -ERANGE;	532	return -ERANGE;
533		533
534	if (GFS2_EA_IS_STUFFED(el->el_ea)) {	534	if (GFS2_EA_IS_STUFFED(el->el_ea)) {
535	memcpy(data, GFS2_EA2DATA(el->el_ea), len);	535	memcpy(data, GFS2_EA2DATA(el->el_ea), len);
536	return len;	536	return len;
537	}	537	}
538	ret = gfs2_iter_unstuffed(ip, el->el_ea, NULL, data);	538	ret = gfs2_iter_unstuffed(ip, el->el_ea, NULL, data);
539	if (ret < 0)	539	if (ret < 0)
540	return ret;	540	return ret;
541	return len;	541	return len;
542	}	542	}
543		543
544	int gfs2_xattr_acl_get(struct gfs2_inode ip, const char name, char **ppdata)	544	int gfs2_xattr_acl_get(struct gfs2_inode ip, const char name, char **ppdata)
545	{	545	{
546	struct gfs2_ea_location el;	546	struct gfs2_ea_location el;
547	int error;	547	int error;
548	int len;	548	int len;
549	char *data;	549	char *data;
550		550
551	error = gfs2_ea_find(ip, GFS2_EATYPE_SYS, name, &el);	551	error = gfs2_ea_find(ip, GFS2_EATYPE_SYS, name, &el);
552	if (error)	552	if (error)
553	return error;	553	return error;
554	if (!el.el_ea)	554	if (!el.el_ea)
555	goto out;	555	goto out;
556	if (!GFS2_EA_DATA_LEN(el.el_ea))	556	if (!GFS2_EA_DATA_LEN(el.el_ea))
557	goto out;	557	goto out;
558		558
559	len = GFS2_EA_DATA_LEN(el.el_ea);	559	len = GFS2_EA_DATA_LEN(el.el_ea);
560	data = kmalloc(len, GFP_NOFS);	560	data = kmalloc(len, GFP_NOFS);
561	error = -ENOMEM;	561	error = -ENOMEM;
562	if (data == NULL)	562	if (data == NULL)
563	goto out;	563	goto out;
564		564
565	error = gfs2_ea_get_copy(ip, &el, data, len);	565	error = gfs2_ea_get_copy(ip, &el, data, len);
566	if (error < 0)	566	if (error < 0)
567	kfree(data);	567	kfree(data);
568	else	568	else
569	*ppdata = data;	569	*ppdata = data;
570	out:	570	out:
571	brelse(el.el_bh);	571	brelse(el.el_bh);
572	return error;	572	return error;
573	}	573	}
574		574
575	/**	575	/**
576	* gfs2_xattr_get - Get a GFS2 extended attribute	576	* gfs2_xattr_get - Get a GFS2 extended attribute
577	* @inode: The inode	577	* @inode: The inode
578	* @name: The name of the extended attribute	578	* @name: The name of the extended attribute
579	* @buffer: The buffer to write the result into	579	* @buffer: The buffer to write the result into
580	* @size: The size of the buffer	580	* @size: The size of the buffer
581	* @type: The type of extended attribute	581	* @type: The type of extended attribute
582	*	582	*
583	* Returns: actual size of data on success, -errno on error	583	* Returns: actual size of data on success, -errno on error
584	*/	584	*/
585	static int gfs2_xattr_get(struct dentry dentry, const char name,	585	static int gfs2_xattr_get(struct dentry dentry, const char name,
586	void *buffer, size_t size, int type)	586	void *buffer, size_t size, int type)
587	{	587	{
588	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);	588	struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
589	struct gfs2_ea_location el;	589	struct gfs2_ea_location el;
590	int error;	590	int error;
591		591
592	if (!ip->i_eattr)	592	if (!ip->i_eattr)
593	return -ENODATA;	593	return -ENODATA;
594	if (strlen(name) > GFS2_EA_MAX_NAME_LEN)	594	if (strlen(name) > GFS2_EA_MAX_NAME_LEN)
595	return -EINVAL;	595	return -EINVAL;
596		596
597	error = gfs2_ea_find(ip, type, name, &el);	597	error = gfs2_ea_find(ip, type, name, &el);
598	if (error)	598	if (error)
599	return error;	599	return error;
600	if (!el.el_ea)	600	if (!el.el_ea)
601	return -ENODATA;	601	return -ENODATA;
602	if (size)	602	if (size)
603	error = gfs2_ea_get_copy(ip, &el, buffer, size);	603	error = gfs2_ea_get_copy(ip, &el, buffer, size);
604	else	604	else
605	error = GFS2_EA_DATA_LEN(el.el_ea);	605	error = GFS2_EA_DATA_LEN(el.el_ea);
606	brelse(el.el_bh);	606	brelse(el.el_bh);
607		607
608	return error;	608	return error;
609	}	609	}
610		610
611	/**	611	/**
612	* ea_alloc_blk - allocates a new block for extended attributes.	612	* ea_alloc_blk - allocates a new block for extended attributes.
613	* @ip: A pointer to the inode that's getting extended attributes	613	* @ip: A pointer to the inode that's getting extended attributes
614	* @bhp: Pointer to pointer to a struct buffer_head	614	* @bhp: Pointer to pointer to a struct buffer_head
615	*	615	*
616	* Returns: errno	616	* Returns: errno
617	*/	617	*/
618		618
619	static int ea_alloc_blk(struct gfs2_inode ip, struct buffer_head *bhp)	619	static int ea_alloc_blk(struct gfs2_inode ip, struct buffer_head *bhp)
620	{	620	{
621	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	621	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
622	struct gfs2_ea_header *ea;	622	struct gfs2_ea_header *ea;
623	unsigned int n = 1;	623	unsigned int n = 1;
624	u64 block;	624	u64 block;
625	int error;	625	int error;
626		626
627	error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);	627	error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
628	if (error)	628	if (error)
629	return error;	629	return error;
630	gfs2_trans_add_unrevoke(sdp, block, 1);	630	gfs2_trans_add_unrevoke(sdp, block, 1);
631	*bhp = gfs2_meta_new(ip->i_gl, block);	631	*bhp = gfs2_meta_new(ip->i_gl, block);
632	gfs2_trans_add_bh(ip->i_gl, *bhp, 1);	632	gfs2_trans_add_bh(ip->i_gl, *bhp, 1);
633	gfs2_metatype_set(*bhp, GFS2_METATYPE_EA, GFS2_FORMAT_EA);	633	gfs2_metatype_set(*bhp, GFS2_METATYPE_EA, GFS2_FORMAT_EA);
634	gfs2_buffer_clear_tail(*bhp, sizeof(struct gfs2_meta_header));	634	gfs2_buffer_clear_tail(*bhp, sizeof(struct gfs2_meta_header));
635		635
636	ea = GFS2_EA_BH2FIRST(*bhp);	636	ea = GFS2_EA_BH2FIRST(*bhp);
637	ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize);	637	ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize);
638	ea->ea_type = GFS2_EATYPE_UNUSED;	638	ea->ea_type = GFS2_EATYPE_UNUSED;
639	ea->ea_flags = GFS2_EAFLAG_LAST;	639	ea->ea_flags = GFS2_EAFLAG_LAST;
640	ea->ea_num_ptrs = 0;	640	ea->ea_num_ptrs = 0;
641		641
642	gfs2_add_inode_blocks(&ip->i_inode, 1);	642	gfs2_add_inode_blocks(&ip->i_inode, 1);
643		643
644	return 0;	644	return 0;
645	}	645	}
646		646
647	/**	647	/**
648	* ea_write - writes the request info to an ea, creating new blocks if	648	* ea_write - writes the request info to an ea, creating new blocks if
649	* necessary	649	* necessary
650	* @ip: inode that is being modified	650	* @ip: inode that is being modified
651	* @ea: the location of the new ea in a block	651	* @ea: the location of the new ea in a block
652	* @er: the write request	652	* @er: the write request
653	*	653	*
654	* Note: does not update ea_rec_len or the GFS2_EAFLAG_LAST bin of ea_flags	654	* Note: does not update ea_rec_len or the GFS2_EAFLAG_LAST bin of ea_flags
655	*	655	*
656	* returns : errno	656	* returns : errno
657	*/	657	*/
658		658
659	static int ea_write(struct gfs2_inode ip, struct gfs2_ea_header ea,	659	static int ea_write(struct gfs2_inode ip, struct gfs2_ea_header ea,
660	struct gfs2_ea_request *er)	660	struct gfs2_ea_request *er)
661	{	661	{
662	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	662	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
663	int error;	663	int error;
664		664
665	ea->ea_data_len = cpu_to_be32(er->er_data_len);	665	ea->ea_data_len = cpu_to_be32(er->er_data_len);
666	ea->ea_name_len = er->er_name_len;	666	ea->ea_name_len = er->er_name_len;
667	ea->ea_type = er->er_type;	667	ea->ea_type = er->er_type;
668	ea->__pad = 0;	668	ea->__pad = 0;
669		669
670	memcpy(GFS2_EA2NAME(ea), er->er_name, er->er_name_len);	670	memcpy(GFS2_EA2NAME(ea), er->er_name, er->er_name_len);
671		671
672	if (GFS2_EAREQ_SIZE_STUFFED(er) <= sdp->sd_jbsize) {	672	if (GFS2_EAREQ_SIZE_STUFFED(er) <= sdp->sd_jbsize) {
673	ea->ea_num_ptrs = 0;	673	ea->ea_num_ptrs = 0;
674	memcpy(GFS2_EA2DATA(ea), er->er_data, er->er_data_len);	674	memcpy(GFS2_EA2DATA(ea), er->er_data, er->er_data_len);
675	} else {	675	} else {
676	__be64 *dataptr = GFS2_EA2DATAPTRS(ea);	676	__be64 *dataptr = GFS2_EA2DATAPTRS(ea);
677	const char *data = er->er_data;	677	const char *data = er->er_data;
678	unsigned int data_len = er->er_data_len;	678	unsigned int data_len = er->er_data_len;
679	unsigned int copy;	679	unsigned int copy;
680	unsigned int x;	680	unsigned int x;
681		681
682	ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize);	682	ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize);
683	for (x = 0; x < ea->ea_num_ptrs; x++) {	683	for (x = 0; x < ea->ea_num_ptrs; x++) {
684	struct buffer_head *bh;	684	struct buffer_head *bh;
685	u64 block;	685	u64 block;
686	int mh_size = sizeof(struct gfs2_meta_header);	686	int mh_size = sizeof(struct gfs2_meta_header);
687	unsigned int n = 1;	687	unsigned int n = 1;
688		688
689	error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);	689	error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
690	if (error)	690	if (error)
691	return error;	691	return error;
692	gfs2_trans_add_unrevoke(sdp, block, 1);	692	gfs2_trans_add_unrevoke(sdp, block, 1);
693	bh = gfs2_meta_new(ip->i_gl, block);	693	bh = gfs2_meta_new(ip->i_gl, block);
694	gfs2_trans_add_bh(ip->i_gl, bh, 1);	694	gfs2_trans_add_bh(ip->i_gl, bh, 1);
695	gfs2_metatype_set(bh, GFS2_METATYPE_ED, GFS2_FORMAT_ED);	695	gfs2_metatype_set(bh, GFS2_METATYPE_ED, GFS2_FORMAT_ED);
696		696
697	gfs2_add_inode_blocks(&ip->i_inode, 1);	697	gfs2_add_inode_blocks(&ip->i_inode, 1);
698		698
699	copy = data_len > sdp->sd_jbsize ? sdp->sd_jbsize :	699	copy = data_len > sdp->sd_jbsize ? sdp->sd_jbsize :
700	data_len;	700	data_len;
701	memcpy(bh->b_data + mh_size, data, copy);	701	memcpy(bh->b_data + mh_size, data, copy);
702	if (copy < sdp->sd_jbsize)	702	if (copy < sdp->sd_jbsize)
703	memset(bh->b_data + mh_size + copy, 0,	703	memset(bh->b_data + mh_size + copy, 0,
704	sdp->sd_jbsize - copy);	704	sdp->sd_jbsize - copy);
705		705
706	*dataptr++ = cpu_to_be64(bh->b_blocknr);	706	*dataptr++ = cpu_to_be64(bh->b_blocknr);
707	data += copy;	707	data += copy;
708	data_len -= copy;	708	data_len -= copy;
709		709
710	brelse(bh);	710	brelse(bh);
711	}	711	}
712		712
713	gfs2_assert_withdraw(sdp, !data_len);	713	gfs2_assert_withdraw(sdp, !data_len);
714	}	714	}
715		715
716	return 0;	716	return 0;
717	}	717	}
718		718
719	typedef int (ea_skeleton_call_t) (struct gfs2_inode ip,	719	typedef int (ea_skeleton_call_t) (struct gfs2_inode ip,
720	struct gfs2_ea_request er, void private);	720	struct gfs2_ea_request er, void private);
721		721
722	static int ea_alloc_skeleton(struct gfs2_inode ip, struct gfs2_ea_request er,	722	static int ea_alloc_skeleton(struct gfs2_inode ip, struct gfs2_ea_request er,
723	unsigned int blks,	723	unsigned int blks,
724	ea_skeleton_call_t skeleton_call, void *private)	724	ea_skeleton_call_t skeleton_call, void *private)
725	{	725	{
726	struct buffer_head *dibh;	726	struct buffer_head *dibh;
727	int error;	727	int error;
728		728
729	error = gfs2_rindex_update(GFS2_SB(&ip->i_inode));	729	error = gfs2_rindex_update(GFS2_SB(&ip->i_inode));
730	if (error)	730	if (error)
731	return error;	731	return error;
732		732
733	error = gfs2_quota_lock_check(ip);	733	error = gfs2_quota_lock_check(ip);
734	if (error)	734	if (error)
735	return error;	735	return error;
736		736
737	error = gfs2_inplace_reserve(ip, blks);	737	error = gfs2_inplace_reserve(ip, blks, 0);
738	if (error)	738	if (error)
739	goto out_gunlock_q;	739	goto out_gunlock_q;
740		740
741	error = gfs2_trans_begin(GFS2_SB(&ip->i_inode),	741	error = gfs2_trans_begin(GFS2_SB(&ip->i_inode),
742	blks + gfs2_rg_blocks(ip, blks) +	742	blks + gfs2_rg_blocks(ip, blks) +
743	RES_DINODE + RES_STATFS + RES_QUOTA, 0);	743	RES_DINODE + RES_STATFS + RES_QUOTA, 0);
744	if (error)	744	if (error)
745	goto out_ipres;	745	goto out_ipres;
746		746
747	error = skeleton_call(ip, er, private);	747	error = skeleton_call(ip, er, private);
748	if (error)	748	if (error)
749	goto out_end_trans;	749	goto out_end_trans;
750		750
751	error = gfs2_meta_inode_buffer(ip, &dibh);	751	error = gfs2_meta_inode_buffer(ip, &dibh);
752	if (!error) {	752	if (!error) {
753	ip->i_inode.i_ctime = CURRENT_TIME;	753	ip->i_inode.i_ctime = CURRENT_TIME;
754	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	754	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
755	gfs2_dinode_out(ip, dibh->b_data);	755	gfs2_dinode_out(ip, dibh->b_data);
756	brelse(dibh);	756	brelse(dibh);
757	}	757	}
758		758
759	out_end_trans:	759	out_end_trans:
760	gfs2_trans_end(GFS2_SB(&ip->i_inode));	760	gfs2_trans_end(GFS2_SB(&ip->i_inode));
761	out_ipres:	761	out_ipres:
762	gfs2_inplace_release(ip);	762	gfs2_inplace_release(ip);
763	out_gunlock_q:	763	out_gunlock_q:
764	gfs2_quota_unlock(ip);	764	gfs2_quota_unlock(ip);
765	return error;	765	return error;
766	}	766	}
767		767
768	static int ea_init_i(struct gfs2_inode ip, struct gfs2_ea_request er,	768	static int ea_init_i(struct gfs2_inode ip, struct gfs2_ea_request er,
769	void *private)	769	void *private)
770	{	770	{
771	struct buffer_head *bh;	771	struct buffer_head *bh;
772	int error;	772	int error;
773		773
774	error = ea_alloc_blk(ip, &bh);	774	error = ea_alloc_blk(ip, &bh);
775	if (error)	775	if (error)
776	return error;	776	return error;
777		777
778	ip->i_eattr = bh->b_blocknr;	778	ip->i_eattr = bh->b_blocknr;
779	error = ea_write(ip, GFS2_EA_BH2FIRST(bh), er);	779	error = ea_write(ip, GFS2_EA_BH2FIRST(bh), er);
780		780
781	brelse(bh);	781	brelse(bh);
782		782
783	return error;	783	return error;
784	}	784	}
785		785
786	/**	786	/**
787	* ea_init - initializes a new eattr block	787	* ea_init - initializes a new eattr block
788	* @ip:	788	* @ip:
789	* @er:	789	* @er:
790	*	790	*
791	* Returns: errno	791	* Returns: errno
792	*/	792	*/
793		793
794	static int ea_init(struct gfs2_inode ip, int type, const char name,	794	static int ea_init(struct gfs2_inode ip, int type, const char name,
795	const void *data, size_t size)	795	const void *data, size_t size)
796	{	796	{
797	struct gfs2_ea_request er;	797	struct gfs2_ea_request er;
798	unsigned int jbsize = GFS2_SB(&ip->i_inode)->sd_jbsize;	798	unsigned int jbsize = GFS2_SB(&ip->i_inode)->sd_jbsize;
799	unsigned int blks = 1;	799	unsigned int blks = 1;
800		800
801	er.er_type = type;	801	er.er_type = type;
802	er.er_name = name;	802	er.er_name = name;
803	er.er_name_len = strlen(name);	803	er.er_name_len = strlen(name);
804	er.er_data = (void *)data;	804	er.er_data = (void *)data;
805	er.er_data_len = size;	805	er.er_data_len = size;
806		806
807	if (GFS2_EAREQ_SIZE_STUFFED(&er) > jbsize)	807	if (GFS2_EAREQ_SIZE_STUFFED(&er) > jbsize)
808	blks += DIV_ROUND_UP(er.er_data_len, jbsize);	808	blks += DIV_ROUND_UP(er.er_data_len, jbsize);
809		809
810	return ea_alloc_skeleton(ip, &er, blks, ea_init_i, NULL);	810	return ea_alloc_skeleton(ip, &er, blks, ea_init_i, NULL);
811	}	811	}
812		812
813	static struct gfs2_ea_header ea_split_ea(struct gfs2_ea_header ea)	813	static struct gfs2_ea_header ea_split_ea(struct gfs2_ea_header ea)
814	{	814	{
815	u32 ea_size = GFS2_EA_SIZE(ea);	815	u32 ea_size = GFS2_EA_SIZE(ea);
816	struct gfs2_ea_header new = (struct gfs2_ea_header )((char *)ea +	816	struct gfs2_ea_header new = (struct gfs2_ea_header )((char *)ea +
817	ea_size);	817	ea_size);
818	u32 new_size = GFS2_EA_REC_LEN(ea) - ea_size;	818	u32 new_size = GFS2_EA_REC_LEN(ea) - ea_size;
819	int last = ea->ea_flags & GFS2_EAFLAG_LAST;	819	int last = ea->ea_flags & GFS2_EAFLAG_LAST;
820		820
821	ea->ea_rec_len = cpu_to_be32(ea_size);	821	ea->ea_rec_len = cpu_to_be32(ea_size);
822	ea->ea_flags ^= last;	822	ea->ea_flags ^= last;
823		823
824	new->ea_rec_len = cpu_to_be32(new_size);	824	new->ea_rec_len = cpu_to_be32(new_size);
825	new->ea_flags = last;	825	new->ea_flags = last;
826		826
827	return new;	827	return new;
828	}	828	}
829		829
830	static void ea_set_remove_stuffed(struct gfs2_inode *ip,	830	static void ea_set_remove_stuffed(struct gfs2_inode *ip,
831	struct gfs2_ea_location *el)	831	struct gfs2_ea_location *el)
832	{	832	{
833	struct gfs2_ea_header *ea = el->el_ea;	833	struct gfs2_ea_header *ea = el->el_ea;
834	struct gfs2_ea_header *prev = el->el_prev;	834	struct gfs2_ea_header *prev = el->el_prev;
835	u32 len;	835	u32 len;
836		836
837	gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);	837	gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
838		838
839	if (!prev \|\| !GFS2_EA_IS_STUFFED(ea)) {	839	if (!prev \|\| !GFS2_EA_IS_STUFFED(ea)) {
840	ea->ea_type = GFS2_EATYPE_UNUSED;	840	ea->ea_type = GFS2_EATYPE_UNUSED;
841	return;	841	return;
842	} else if (GFS2_EA2NEXT(prev) != ea) {	842	} else if (GFS2_EA2NEXT(prev) != ea) {
843	prev = GFS2_EA2NEXT(prev);	843	prev = GFS2_EA2NEXT(prev);
844	gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), GFS2_EA2NEXT(prev) == ea);	844	gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), GFS2_EA2NEXT(prev) == ea);
845	}	845	}
846		846
847	len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);	847	len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
848	prev->ea_rec_len = cpu_to_be32(len);	848	prev->ea_rec_len = cpu_to_be32(len);
849		849
850	if (GFS2_EA_IS_LAST(ea))	850	if (GFS2_EA_IS_LAST(ea))
851	prev->ea_flags \|= GFS2_EAFLAG_LAST;	851	prev->ea_flags \|= GFS2_EAFLAG_LAST;
852	}	852	}
853		853
854	struct ea_set {	854	struct ea_set {
855	int ea_split;	855	int ea_split;
856		856
857	struct gfs2_ea_request *es_er;	857	struct gfs2_ea_request *es_er;
858	struct gfs2_ea_location *es_el;	858	struct gfs2_ea_location *es_el;
859		859
860	struct buffer_head *es_bh;	860	struct buffer_head *es_bh;
861	struct gfs2_ea_header *es_ea;	861	struct gfs2_ea_header *es_ea;
862	};	862	};
863		863
864	static int ea_set_simple_noalloc(struct gfs2_inode ip, struct buffer_head bh,	864	static int ea_set_simple_noalloc(struct gfs2_inode ip, struct buffer_head bh,
865	struct gfs2_ea_header ea, struct ea_set es)	865	struct gfs2_ea_header ea, struct ea_set es)
866	{	866	{
867	struct gfs2_ea_request *er = es->es_er;	867	struct gfs2_ea_request *er = es->es_er;
868	struct buffer_head *dibh;	868	struct buffer_head *dibh;
869	int error;	869	int error;
870		870
871	error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + 2 * RES_EATTR, 0);	871	error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + 2 * RES_EATTR, 0);
872	if (error)	872	if (error)
873	return error;	873	return error;
874		874
875	gfs2_trans_add_bh(ip->i_gl, bh, 1);	875	gfs2_trans_add_bh(ip->i_gl, bh, 1);
876		876
877	if (es->ea_split)	877	if (es->ea_split)
878	ea = ea_split_ea(ea);	878	ea = ea_split_ea(ea);
879		879
880	ea_write(ip, ea, er);	880	ea_write(ip, ea, er);
881		881
882	if (es->es_el)	882	if (es->es_el)
883	ea_set_remove_stuffed(ip, es->es_el);	883	ea_set_remove_stuffed(ip, es->es_el);
884		884
885	error = gfs2_meta_inode_buffer(ip, &dibh);	885	error = gfs2_meta_inode_buffer(ip, &dibh);
886	if (error)	886	if (error)
887	goto out;	887	goto out;
888	ip->i_inode.i_ctime = CURRENT_TIME;	888	ip->i_inode.i_ctime = CURRENT_TIME;
889	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	889	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
890	gfs2_dinode_out(ip, dibh->b_data);	890	gfs2_dinode_out(ip, dibh->b_data);
891	brelse(dibh);	891	brelse(dibh);
892	out:	892	out:
893	gfs2_trans_end(GFS2_SB(&ip->i_inode));	893	gfs2_trans_end(GFS2_SB(&ip->i_inode));
894	return error;	894	return error;
895	}	895	}
896		896
897	static int ea_set_simple_alloc(struct gfs2_inode *ip,	897	static int ea_set_simple_alloc(struct gfs2_inode *ip,
898	struct gfs2_ea_request er, void private)	898	struct gfs2_ea_request er, void private)
899	{	899	{
900	struct ea_set *es = private;	900	struct ea_set *es = private;
901	struct gfs2_ea_header *ea = es->es_ea;	901	struct gfs2_ea_header *ea = es->es_ea;
902	int error;	902	int error;
903		903
904	gfs2_trans_add_bh(ip->i_gl, es->es_bh, 1);	904	gfs2_trans_add_bh(ip->i_gl, es->es_bh, 1);
905		905
906	if (es->ea_split)	906	if (es->ea_split)
907	ea = ea_split_ea(ea);	907	ea = ea_split_ea(ea);
908		908
909	error = ea_write(ip, ea, er);	909	error = ea_write(ip, ea, er);
910	if (error)	910	if (error)
911	return error;	911	return error;
912		912
913	if (es->es_el)	913	if (es->es_el)
914	ea_set_remove_stuffed(ip, es->es_el);	914	ea_set_remove_stuffed(ip, es->es_el);
915		915
916	return 0;	916	return 0;
917	}	917	}
918		918
919	static int ea_set_simple(struct gfs2_inode ip, struct buffer_head bh,	919	static int ea_set_simple(struct gfs2_inode ip, struct buffer_head bh,
920	struct gfs2_ea_header ea, struct gfs2_ea_header prev,	920	struct gfs2_ea_header ea, struct gfs2_ea_header prev,
921	void *private)	921	void *private)
922	{	922	{
923	struct ea_set *es = private;	923	struct ea_set *es = private;
924	unsigned int size;	924	unsigned int size;
925	int stuffed;	925	int stuffed;
926	int error;	926	int error;
927		927
928	stuffed = ea_calc_size(GFS2_SB(&ip->i_inode), es->es_er->er_name_len,	928	stuffed = ea_calc_size(GFS2_SB(&ip->i_inode), es->es_er->er_name_len,
929	es->es_er->er_data_len, &size);	929	es->es_er->er_data_len, &size);
930		930
931	if (ea->ea_type == GFS2_EATYPE_UNUSED) {	931	if (ea->ea_type == GFS2_EATYPE_UNUSED) {
932	if (GFS2_EA_REC_LEN(ea) < size)	932	if (GFS2_EA_REC_LEN(ea) < size)
933	return 0;	933	return 0;
934	if (!GFS2_EA_IS_STUFFED(ea)) {	934	if (!GFS2_EA_IS_STUFFED(ea)) {
935	error = ea_remove_unstuffed(ip, bh, ea, prev, 1);	935	error = ea_remove_unstuffed(ip, bh, ea, prev, 1);
936	if (error)	936	if (error)
937	return error;	937	return error;
938	}	938	}
939	es->ea_split = 0;	939	es->ea_split = 0;
940	} else if (GFS2_EA_REC_LEN(ea) - GFS2_EA_SIZE(ea) >= size)	940	} else if (GFS2_EA_REC_LEN(ea) - GFS2_EA_SIZE(ea) >= size)
941	es->ea_split = 1;	941	es->ea_split = 1;
942	else	942	else
943	return 0;	943	return 0;
944		944
945	if (stuffed) {	945	if (stuffed) {
946	error = ea_set_simple_noalloc(ip, bh, ea, es);	946	error = ea_set_simple_noalloc(ip, bh, ea, es);
947	if (error)	947	if (error)
948	return error;	948	return error;
949	} else {	949	} else {
950	unsigned int blks;	950	unsigned int blks;
951		951
952	es->es_bh = bh;	952	es->es_bh = bh;
953	es->es_ea = ea;	953	es->es_ea = ea;
954	blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len,	954	blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len,
955	GFS2_SB(&ip->i_inode)->sd_jbsize);	955	GFS2_SB(&ip->i_inode)->sd_jbsize);
956		956
957	error = ea_alloc_skeleton(ip, es->es_er, blks,	957	error = ea_alloc_skeleton(ip, es->es_er, blks,
958	ea_set_simple_alloc, es);	958	ea_set_simple_alloc, es);
959	if (error)	959	if (error)
960	return error;	960	return error;
961	}	961	}
962		962
963	return 1;	963	return 1;
964	}	964	}
965		965
966	static int ea_set_block(struct gfs2_inode ip, struct gfs2_ea_request er,	966	static int ea_set_block(struct gfs2_inode ip, struct gfs2_ea_request er,
967	void *private)	967	void *private)
968	{	968	{
969	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	969	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
970	struct buffer_head indbh, newbh;	970	struct buffer_head indbh, newbh;
971	__be64 *eablk;	971	__be64 *eablk;
972	int error;	972	int error;
973	int mh_size = sizeof(struct gfs2_meta_header);	973	int mh_size = sizeof(struct gfs2_meta_header);
974		974
975	if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {	975	if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
976	__be64 *end;	976	__be64 *end;
977		977
978	error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT,	978	error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT,
979	&indbh);	979	&indbh);
980	if (error)	980	if (error)
981	return error;	981	return error;
982		982
983	if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {	983	if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
984	error = -EIO;	984	error = -EIO;
985	goto out;	985	goto out;
986	}	986	}
987		987
988	eablk = (__be64 *)(indbh->b_data + mh_size);	988	eablk = (__be64 *)(indbh->b_data + mh_size);
989	end = eablk + sdp->sd_inptrs;	989	end = eablk + sdp->sd_inptrs;
990		990
991	for (; eablk < end; eablk++)	991	for (; eablk < end; eablk++)
992	if (!*eablk)	992	if (!*eablk)
993	break;	993	break;
994		994
995	if (eablk == end) {	995	if (eablk == end) {
996	error = -ENOSPC;	996	error = -ENOSPC;
997	goto out;	997	goto out;
998	}	998	}
999		999
1000	gfs2_trans_add_bh(ip->i_gl, indbh, 1);	1000	gfs2_trans_add_bh(ip->i_gl, indbh, 1);
1001	} else {	1001	} else {
1002	u64 blk;	1002	u64 blk;
1003	unsigned int n = 1;	1003	unsigned int n = 1;
1004	error = gfs2_alloc_blocks(ip, &blk, &n, 0, NULL);	1004	error = gfs2_alloc_blocks(ip, &blk, &n, 0, NULL);
1005	if (error)	1005	if (error)
1006	return error;	1006	return error;
1007	gfs2_trans_add_unrevoke(sdp, blk, 1);	1007	gfs2_trans_add_unrevoke(sdp, blk, 1);
1008	indbh = gfs2_meta_new(ip->i_gl, blk);	1008	indbh = gfs2_meta_new(ip->i_gl, blk);
1009	gfs2_trans_add_bh(ip->i_gl, indbh, 1);	1009	gfs2_trans_add_bh(ip->i_gl, indbh, 1);
1010	gfs2_metatype_set(indbh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);	1010	gfs2_metatype_set(indbh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);
1011	gfs2_buffer_clear_tail(indbh, mh_size);	1011	gfs2_buffer_clear_tail(indbh, mh_size);
1012		1012
1013	eablk = (__be64 *)(indbh->b_data + mh_size);	1013	eablk = (__be64 *)(indbh->b_data + mh_size);
1014	*eablk = cpu_to_be64(ip->i_eattr);	1014	*eablk = cpu_to_be64(ip->i_eattr);
1015	ip->i_eattr = blk;	1015	ip->i_eattr = blk;
1016	ip->i_diskflags \|= GFS2_DIF_EA_INDIRECT;	1016	ip->i_diskflags \|= GFS2_DIF_EA_INDIRECT;
1017	gfs2_add_inode_blocks(&ip->i_inode, 1);	1017	gfs2_add_inode_blocks(&ip->i_inode, 1);
1018		1018
1019	eablk++;	1019	eablk++;
1020	}	1020	}
1021		1021
1022	error = ea_alloc_blk(ip, &newbh);	1022	error = ea_alloc_blk(ip, &newbh);
1023	if (error)	1023	if (error)
1024	goto out;	1024	goto out;
1025		1025
1026	*eablk = cpu_to_be64((u64)newbh->b_blocknr);	1026	*eablk = cpu_to_be64((u64)newbh->b_blocknr);
1027	error = ea_write(ip, GFS2_EA_BH2FIRST(newbh), er);	1027	error = ea_write(ip, GFS2_EA_BH2FIRST(newbh), er);
1028	brelse(newbh);	1028	brelse(newbh);
1029	if (error)	1029	if (error)
1030	goto out;	1030	goto out;
1031		1031
1032	if (private)	1032	if (private)
1033	ea_set_remove_stuffed(ip, private);	1033	ea_set_remove_stuffed(ip, private);
1034		1034
1035	out:	1035	out:
1036	brelse(indbh);	1036	brelse(indbh);
1037	return error;	1037	return error;
1038	}	1038	}
1039		1039
1040	static int ea_set_i(struct gfs2_inode ip, int type, const char name,	1040	static int ea_set_i(struct gfs2_inode ip, int type, const char name,
1041	const void value, size_t size, struct gfs2_ea_location el)	1041	const void value, size_t size, struct gfs2_ea_location el)
1042	{	1042	{
1043	struct gfs2_ea_request er;	1043	struct gfs2_ea_request er;
1044	struct ea_set es;	1044	struct ea_set es;
1045	unsigned int blks = 2;	1045	unsigned int blks = 2;
1046	int error;	1046	int error;
1047		1047
1048	er.er_type = type;	1048	er.er_type = type;
1049	er.er_name = name;	1049	er.er_name = name;
1050	er.er_data = (void *)value;	1050	er.er_data = (void *)value;
1051	er.er_name_len = strlen(name);	1051	er.er_name_len = strlen(name);
1052	er.er_data_len = size;	1052	er.er_data_len = size;
1053		1053
1054	memset(&es, 0, sizeof(struct ea_set));	1054	memset(&es, 0, sizeof(struct ea_set));
1055	es.es_er = &er;	1055	es.es_er = &er;
1056	es.es_el = el;	1056	es.es_el = el;
1057		1057
1058	error = ea_foreach(ip, ea_set_simple, &es);	1058	error = ea_foreach(ip, ea_set_simple, &es);
1059	if (error > 0)	1059	if (error > 0)
1060	return 0;	1060	return 0;
1061	if (error)	1061	if (error)
1062	return error;	1062	return error;
1063		1063
1064	if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT))	1064	if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT))
1065	blks++;	1065	blks++;
1066	if (GFS2_EAREQ_SIZE_STUFFED(&er) > GFS2_SB(&ip->i_inode)->sd_jbsize)	1066	if (GFS2_EAREQ_SIZE_STUFFED(&er) > GFS2_SB(&ip->i_inode)->sd_jbsize)
1067	blks += DIV_ROUND_UP(er.er_data_len, GFS2_SB(&ip->i_inode)->sd_jbsize);	1067	blks += DIV_ROUND_UP(er.er_data_len, GFS2_SB(&ip->i_inode)->sd_jbsize);
1068		1068
1069	return ea_alloc_skeleton(ip, &er, blks, ea_set_block, el);	1069	return ea_alloc_skeleton(ip, &er, blks, ea_set_block, el);
1070	}	1070	}
1071		1071
1072	static int ea_set_remove_unstuffed(struct gfs2_inode *ip,	1072	static int ea_set_remove_unstuffed(struct gfs2_inode *ip,
1073	struct gfs2_ea_location *el)	1073	struct gfs2_ea_location *el)
1074	{	1074	{
1075	if (el->el_prev && GFS2_EA2NEXT(el->el_prev) != el->el_ea) {	1075	if (el->el_prev && GFS2_EA2NEXT(el->el_prev) != el->el_ea) {
1076	el->el_prev = GFS2_EA2NEXT(el->el_prev);	1076	el->el_prev = GFS2_EA2NEXT(el->el_prev);
1077	gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),	1077	gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
1078	GFS2_EA2NEXT(el->el_prev) == el->el_ea);	1078	GFS2_EA2NEXT(el->el_prev) == el->el_ea);
1079	}	1079	}
1080		1080
1081	return ea_remove_unstuffed(ip, el->el_bh, el->el_ea, el->el_prev, 0);	1081	return ea_remove_unstuffed(ip, el->el_bh, el->el_ea, el->el_prev, 0);
1082	}	1082	}
1083		1083
1084	static int ea_remove_stuffed(struct gfs2_inode ip, struct gfs2_ea_location el)	1084	static int ea_remove_stuffed(struct gfs2_inode ip, struct gfs2_ea_location el)
1085	{	1085	{
1086	struct gfs2_ea_header *ea = el->el_ea;	1086	struct gfs2_ea_header *ea = el->el_ea;
1087	struct gfs2_ea_header *prev = el->el_prev;	1087	struct gfs2_ea_header *prev = el->el_prev;
1088	struct buffer_head *dibh;	1088	struct buffer_head *dibh;
1089	int error;	1089	int error;
1090		1090
1091	error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);	1091	error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);
1092	if (error)	1092	if (error)
1093	return error;	1093	return error;
1094		1094
1095	gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);	1095	gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
1096		1096
1097	if (prev) {	1097	if (prev) {
1098	u32 len;	1098	u32 len;
1099		1099
1100	len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);	1100	len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
1101	prev->ea_rec_len = cpu_to_be32(len);	1101	prev->ea_rec_len = cpu_to_be32(len);
1102		1102
1103	if (GFS2_EA_IS_LAST(ea))	1103	if (GFS2_EA_IS_LAST(ea))
1104	prev->ea_flags \|= GFS2_EAFLAG_LAST;	1104	prev->ea_flags \|= GFS2_EAFLAG_LAST;
1105	} else {	1105	} else {
1106	ea->ea_type = GFS2_EATYPE_UNUSED;	1106	ea->ea_type = GFS2_EATYPE_UNUSED;
1107	}	1107	}
1108		1108
1109	error = gfs2_meta_inode_buffer(ip, &dibh);	1109	error = gfs2_meta_inode_buffer(ip, &dibh);
1110	if (!error) {	1110	if (!error) {
1111	ip->i_inode.i_ctime = CURRENT_TIME;	1111	ip->i_inode.i_ctime = CURRENT_TIME;
1112	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	1112	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1113	gfs2_dinode_out(ip, dibh->b_data);	1113	gfs2_dinode_out(ip, dibh->b_data);
1114	brelse(dibh);	1114	brelse(dibh);
1115	}	1115	}
1116		1116
1117	gfs2_trans_end(GFS2_SB(&ip->i_inode));	1117	gfs2_trans_end(GFS2_SB(&ip->i_inode));
1118		1118
1119	return error;	1119	return error;
1120	}	1120	}
1121		1121
1122	/**	1122	/**
1123	* gfs2_xattr_remove - Remove a GFS2 extended attribute	1123	* gfs2_xattr_remove - Remove a GFS2 extended attribute
1124	* @ip: The inode	1124	* @ip: The inode
1125	* @type: The type of the extended attribute	1125	* @type: The type of the extended attribute
1126	* @name: The name of the extended attribute	1126	* @name: The name of the extended attribute
1127	*	1127	*
1128	* This is not called directly by the VFS since we use the (common)	1128	* This is not called directly by the VFS since we use the (common)
1129	* scheme of making a "set with NULL data" mean a remove request. Note	1129	* scheme of making a "set with NULL data" mean a remove request. Note
1130	* that this is different from a set with zero length data.	1130	* that this is different from a set with zero length data.
1131	*	1131	*
1132	* Returns: 0, or errno on failure	1132	* Returns: 0, or errno on failure
1133	*/	1133	*/
1134		1134
1135	static int gfs2_xattr_remove(struct gfs2_inode ip, int type, const char name)	1135	static int gfs2_xattr_remove(struct gfs2_inode ip, int type, const char name)
1136	{	1136	{
1137	struct gfs2_ea_location el;	1137	struct gfs2_ea_location el;
1138	int error;	1138	int error;
1139		1139
1140	if (!ip->i_eattr)	1140	if (!ip->i_eattr)
1141	return -ENODATA;	1141	return -ENODATA;
1142		1142
1143	error = gfs2_ea_find(ip, type, name, &el);	1143	error = gfs2_ea_find(ip, type, name, &el);
1144	if (error)	1144	if (error)
1145	return error;	1145	return error;
1146	if (!el.el_ea)	1146	if (!el.el_ea)
1147	return -ENODATA;	1147	return -ENODATA;
1148		1148
1149	if (GFS2_EA_IS_STUFFED(el.el_ea))	1149	if (GFS2_EA_IS_STUFFED(el.el_ea))
1150	error = ea_remove_stuffed(ip, &el);	1150	error = ea_remove_stuffed(ip, &el);
1151	else	1151	else
1152	error = ea_remove_unstuffed(ip, el.el_bh, el.el_ea, el.el_prev, 0);	1152	error = ea_remove_unstuffed(ip, el.el_bh, el.el_ea, el.el_prev, 0);
1153		1153
1154	brelse(el.el_bh);	1154	brelse(el.el_bh);
1155		1155
1156	return error;	1156	return error;
1157	}	1157	}
1158		1158
1159	/**	1159	/**
1160	* __gfs2_xattr_set - Set (or remove) a GFS2 extended attribute	1160	* __gfs2_xattr_set - Set (or remove) a GFS2 extended attribute
1161	* @ip: The inode	1161	* @ip: The inode
1162	* @name: The name of the extended attribute	1162	* @name: The name of the extended attribute
1163	* @value: The value of the extended attribute (NULL for remove)	1163	* @value: The value of the extended attribute (NULL for remove)
1164	* @size: The size of the @value argument	1164	* @size: The size of the @value argument
1165	* @flags: Create or Replace	1165	* @flags: Create or Replace
1166	* @type: The type of the extended attribute	1166	* @type: The type of the extended attribute
1167	*	1167	*
1168	* See gfs2_xattr_remove() for details of the removal of xattrs.	1168	* See gfs2_xattr_remove() for details of the removal of xattrs.
1169	*	1169	*
1170	* Returns: 0 or errno on failure	1170	* Returns: 0 or errno on failure
1171	*/	1171	*/
1172		1172
1173	int __gfs2_xattr_set(struct inode inode, const char name,	1173	int __gfs2_xattr_set(struct inode inode, const char name,
1174	const void *value, size_t size, int flags, int type)	1174	const void *value, size_t size, int flags, int type)
1175	{	1175	{
1176	struct gfs2_inode *ip = GFS2_I(inode);	1176	struct gfs2_inode *ip = GFS2_I(inode);
1177	struct gfs2_sbd *sdp = GFS2_SB(inode);	1177	struct gfs2_sbd *sdp = GFS2_SB(inode);
1178	struct gfs2_ea_location el;	1178	struct gfs2_ea_location el;
1179	unsigned int namel = strlen(name);	1179	unsigned int namel = strlen(name);
1180	int error;	1180	int error;
1181		1181
1182	if (IS_IMMUTABLE(inode) \|\| IS_APPEND(inode))	1182	if (IS_IMMUTABLE(inode) \|\| IS_APPEND(inode))
1183	return -EPERM;	1183	return -EPERM;
1184	if (namel > GFS2_EA_MAX_NAME_LEN)	1184	if (namel > GFS2_EA_MAX_NAME_LEN)
1185	return -ERANGE;	1185	return -ERANGE;
1186		1186
1187	if (value == NULL)	1187	if (value == NULL)
1188	return gfs2_xattr_remove(ip, type, name);	1188	return gfs2_xattr_remove(ip, type, name);
1189		1189
1190	if (ea_check_size(sdp, namel, size))	1190	if (ea_check_size(sdp, namel, size))
1191	return -ERANGE;	1191	return -ERANGE;
1192		1192
1193	if (!ip->i_eattr) {	1193	if (!ip->i_eattr) {
1194	if (flags & XATTR_REPLACE)	1194	if (flags & XATTR_REPLACE)
1195	return -ENODATA;	1195	return -ENODATA;
1196	return ea_init(ip, type, name, value, size);	1196	return ea_init(ip, type, name, value, size);
1197	}	1197	}
1198		1198
1199	error = gfs2_ea_find(ip, type, name, &el);	1199	error = gfs2_ea_find(ip, type, name, &el);
1200	if (error)	1200	if (error)
1201	return error;	1201	return error;
1202		1202
1203	if (el.el_ea) {	1203	if (el.el_ea) {
1204	if (ip->i_diskflags & GFS2_DIF_APPENDONLY) {	1204	if (ip->i_diskflags & GFS2_DIF_APPENDONLY) {
1205	brelse(el.el_bh);	1205	brelse(el.el_bh);
1206	return -EPERM;	1206	return -EPERM;
1207	}	1207	}
1208		1208
1209	error = -EEXIST;	1209	error = -EEXIST;
1210	if (!(flags & XATTR_CREATE)) {	1210	if (!(flags & XATTR_CREATE)) {
1211	int unstuffed = !GFS2_EA_IS_STUFFED(el.el_ea);	1211	int unstuffed = !GFS2_EA_IS_STUFFED(el.el_ea);
1212	error = ea_set_i(ip, type, name, value, size, &el);	1212	error = ea_set_i(ip, type, name, value, size, &el);
1213	if (!error && unstuffed)	1213	if (!error && unstuffed)
1214	ea_set_remove_unstuffed(ip, &el);	1214	ea_set_remove_unstuffed(ip, &el);
1215	}	1215	}
1216		1216
1217	brelse(el.el_bh);	1217	brelse(el.el_bh);
1218	return error;	1218	return error;
1219	}	1219	}
1220		1220
1221	error = -ENODATA;	1221	error = -ENODATA;
1222	if (!(flags & XATTR_REPLACE))	1222	if (!(flags & XATTR_REPLACE))
1223	error = ea_set_i(ip, type, name, value, size, NULL);	1223	error = ea_set_i(ip, type, name, value, size, NULL);
1224		1224
1225	return error;	1225	return error;
1226	}	1226	}
1227		1227
1228	static int gfs2_xattr_set(struct dentry dentry, const char name,	1228	static int gfs2_xattr_set(struct dentry dentry, const char name,
1229	const void *value, size_t size, int flags, int type)	1229	const void *value, size_t size, int flags, int type)
1230	{	1230	{
1231	return __gfs2_xattr_set(dentry->d_inode, name, value,	1231	return __gfs2_xattr_set(dentry->d_inode, name, value,
1232	size, flags, type);	1232	size, flags, type);
1233	}	1233	}
1234		1234
1235		1235
1236	static int ea_acl_chmod_unstuffed(struct gfs2_inode *ip,	1236	static int ea_acl_chmod_unstuffed(struct gfs2_inode *ip,
1237	struct gfs2_ea_header ea, char data)	1237	struct gfs2_ea_header ea, char data)
1238	{	1238	{
1239	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1239	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1240	unsigned int amount = GFS2_EA_DATA_LEN(ea);	1240	unsigned int amount = GFS2_EA_DATA_LEN(ea);
1241	unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);	1241	unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);
1242	int ret;	1242	int ret;
1243		1243
1244	ret = gfs2_trans_begin(sdp, nptrs + RES_DINODE, 0);	1244	ret = gfs2_trans_begin(sdp, nptrs + RES_DINODE, 0);
1245	if (ret)	1245	if (ret)
1246	return ret;	1246	return ret;
1247		1247
1248	ret = gfs2_iter_unstuffed(ip, ea, data, NULL);	1248	ret = gfs2_iter_unstuffed(ip, ea, data, NULL);
1249	gfs2_trans_end(sdp);	1249	gfs2_trans_end(sdp);
1250		1250
1251	return ret;	1251	return ret;
1252	}	1252	}
1253		1253
1254	int gfs2_xattr_acl_chmod(struct gfs2_inode ip, struct iattr attr, char *data)	1254	int gfs2_xattr_acl_chmod(struct gfs2_inode ip, struct iattr attr, char *data)
1255	{	1255	{
1256	struct inode *inode = &ip->i_inode;	1256	struct inode *inode = &ip->i_inode;
1257	struct gfs2_sbd *sdp = GFS2_SB(inode);	1257	struct gfs2_sbd *sdp = GFS2_SB(inode);
1258	struct gfs2_ea_location el;	1258	struct gfs2_ea_location el;
1259	int error;	1259	int error;
1260		1260
1261	error = gfs2_ea_find(ip, GFS2_EATYPE_SYS, GFS2_POSIX_ACL_ACCESS, &el);	1261	error = gfs2_ea_find(ip, GFS2_EATYPE_SYS, GFS2_POSIX_ACL_ACCESS, &el);
1262	if (error)	1262	if (error)
1263	return error;	1263	return error;
1264		1264
1265	if (GFS2_EA_IS_STUFFED(el.el_ea)) {	1265	if (GFS2_EA_IS_STUFFED(el.el_ea)) {
1266	error = gfs2_trans_begin(sdp, RES_DINODE + RES_EATTR, 0);	1266	error = gfs2_trans_begin(sdp, RES_DINODE + RES_EATTR, 0);
1267	if (error == 0) {	1267	if (error == 0) {
1268	gfs2_trans_add_bh(ip->i_gl, el.el_bh, 1);	1268	gfs2_trans_add_bh(ip->i_gl, el.el_bh, 1);
1269	memcpy(GFS2_EA2DATA(el.el_ea), data,	1269	memcpy(GFS2_EA2DATA(el.el_ea), data,
1270	GFS2_EA_DATA_LEN(el.el_ea));	1270	GFS2_EA_DATA_LEN(el.el_ea));
1271	}	1271	}
1272	} else {	1272	} else {
1273	error = ea_acl_chmod_unstuffed(ip, el.el_ea, data);	1273	error = ea_acl_chmod_unstuffed(ip, el.el_ea, data);
1274	}	1274	}
1275		1275
1276	brelse(el.el_bh);	1276	brelse(el.el_bh);
1277	if (error)	1277	if (error)
1278	return error;	1278	return error;
1279		1279
1280	error = gfs2_setattr_simple(inode, attr);	1280	error = gfs2_setattr_simple(inode, attr);
1281	gfs2_trans_end(sdp);	1281	gfs2_trans_end(sdp);
1282	return error;	1282	return error;
1283	}	1283	}
1284		1284
1285	static int ea_dealloc_indirect(struct gfs2_inode *ip)	1285	static int ea_dealloc_indirect(struct gfs2_inode *ip)
1286	{	1286	{
1287	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1287	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1288	struct gfs2_rgrp_list rlist;	1288	struct gfs2_rgrp_list rlist;
1289	struct buffer_head indbh, dibh;	1289	struct buffer_head indbh, dibh;
1290	__be64 eablk, end;	1290	__be64 eablk, end;
1291	unsigned int rg_blocks = 0;	1291	unsigned int rg_blocks = 0;
1292	u64 bstart = 0;	1292	u64 bstart = 0;
1293	unsigned int blen = 0;	1293	unsigned int blen = 0;
1294	unsigned int blks = 0;	1294	unsigned int blks = 0;
1295	unsigned int x;	1295	unsigned int x;
1296	int error;	1296	int error;
1297		1297
1298	error = gfs2_rindex_update(sdp);	1298	error = gfs2_rindex_update(sdp);
1299	if (error)	1299	if (error)
1300	return error;	1300	return error;
1301		1301
1302	memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));	1302	memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
1303		1303
1304	error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &indbh);	1304	error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &indbh);
1305	if (error)	1305	if (error)
1306	return error;	1306	return error;
1307		1307
1308	if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {	1308	if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
1309	error = -EIO;	1309	error = -EIO;
1310	goto out;	1310	goto out;
1311	}	1311	}
1312		1312
1313	eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));	1313	eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
1314	end = eablk + sdp->sd_inptrs;	1314	end = eablk + sdp->sd_inptrs;
1315		1315
1316	for (; eablk < end; eablk++) {	1316	for (; eablk < end; eablk++) {
1317	u64 bn;	1317	u64 bn;
1318		1318
1319	if (!*eablk)	1319	if (!*eablk)
1320	break;	1320	break;
1321	bn = be64_to_cpu(*eablk);	1321	bn = be64_to_cpu(*eablk);
1322		1322
1323	if (bstart + blen == bn)	1323	if (bstart + blen == bn)
1324	blen++;	1324	blen++;
1325	else {	1325	else {
1326	if (bstart)	1326	if (bstart)
1327	gfs2_rlist_add(ip, &rlist, bstart);	1327	gfs2_rlist_add(ip, &rlist, bstart);
1328	bstart = bn;	1328	bstart = bn;
1329	blen = 1;	1329	blen = 1;
1330	}	1330	}
1331	blks++;	1331	blks++;
1332	}	1332	}
1333	if (bstart)	1333	if (bstart)
1334	gfs2_rlist_add(ip, &rlist, bstart);	1334	gfs2_rlist_add(ip, &rlist, bstart);
1335	else	1335	else
1336	goto out;	1336	goto out;
1337		1337
1338	gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);	1338	gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
1339		1339
1340	for (x = 0; x < rlist.rl_rgrps; x++) {	1340	for (x = 0; x < rlist.rl_rgrps; x++) {
1341	struct gfs2_rgrpd *rgd;	1341	struct gfs2_rgrpd *rgd;
1342	rgd = rlist.rl_ghs[x].gh_gl->gl_object;	1342	rgd = rlist.rl_ghs[x].gh_gl->gl_object;
1343	rg_blocks += rgd->rd_length;	1343	rg_blocks += rgd->rd_length;
1344	}	1344	}
1345		1345
1346	error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);	1346	error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
1347	if (error)	1347	if (error)
1348	goto out_rlist_free;	1348	goto out_rlist_free;
1349		1349
1350	error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE + RES_INDIRECT +	1350	error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE + RES_INDIRECT +
1351	RES_STATFS + RES_QUOTA, blks);	1351	RES_STATFS + RES_QUOTA, blks);
1352	if (error)	1352	if (error)
1353	goto out_gunlock;	1353	goto out_gunlock;
1354		1354
1355	gfs2_trans_add_bh(ip->i_gl, indbh, 1);	1355	gfs2_trans_add_bh(ip->i_gl, indbh, 1);
1356		1356
1357	eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));	1357	eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
1358	bstart = 0;	1358	bstart = 0;
1359	blen = 0;	1359	blen = 0;
1360		1360
1361	for (; eablk < end; eablk++) {	1361	for (; eablk < end; eablk++) {
1362	u64 bn;	1362	u64 bn;
1363		1363
1364	if (!*eablk)	1364	if (!*eablk)
1365	break;	1365	break;
1366	bn = be64_to_cpu(*eablk);	1366	bn = be64_to_cpu(*eablk);
1367		1367
1368	if (bstart + blen == bn)	1368	if (bstart + blen == bn)
1369	blen++;	1369	blen++;
1370	else {	1370	else {
1371	if (bstart)	1371	if (bstart)
1372	gfs2_free_meta(ip, bstart, blen);	1372	gfs2_free_meta(ip, bstart, blen);
1373	bstart = bn;	1373	bstart = bn;
1374	blen = 1;	1374	blen = 1;
1375	}	1375	}
1376		1376
1377	*eablk = 0;	1377	*eablk = 0;
1378	gfs2_add_inode_blocks(&ip->i_inode, -1);	1378	gfs2_add_inode_blocks(&ip->i_inode, -1);
1379	}	1379	}
1380	if (bstart)	1380	if (bstart)
1381	gfs2_free_meta(ip, bstart, blen);	1381	gfs2_free_meta(ip, bstart, blen);
1382		1382
1383	ip->i_diskflags &= ~GFS2_DIF_EA_INDIRECT;	1383	ip->i_diskflags &= ~GFS2_DIF_EA_INDIRECT;
1384		1384
1385	error = gfs2_meta_inode_buffer(ip, &dibh);	1385	error = gfs2_meta_inode_buffer(ip, &dibh);
1386	if (!error) {	1386	if (!error) {
1387	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	1387	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1388	gfs2_dinode_out(ip, dibh->b_data);	1388	gfs2_dinode_out(ip, dibh->b_data);
1389	brelse(dibh);	1389	brelse(dibh);
1390	}	1390	}
1391		1391
1392	gfs2_trans_end(sdp);	1392	gfs2_trans_end(sdp);
1393		1393
1394	out_gunlock:	1394	out_gunlock:
1395	gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);	1395	gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
1396	out_rlist_free:	1396	out_rlist_free:
1397	gfs2_rlist_free(&rlist);	1397	gfs2_rlist_free(&rlist);
1398	out:	1398	out:
1399	brelse(indbh);	1399	brelse(indbh);
1400	return error;	1400	return error;
1401	}	1401	}
1402		1402
1403	static int ea_dealloc_block(struct gfs2_inode *ip)	1403	static int ea_dealloc_block(struct gfs2_inode *ip)
1404	{	1404	{
1405	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);	1405	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1406	struct gfs2_rgrpd *rgd;	1406	struct gfs2_rgrpd *rgd;
1407	struct buffer_head *dibh;	1407	struct buffer_head *dibh;
1408	struct gfs2_holder gh;	1408	struct gfs2_holder gh;
1409	int error;	1409	int error;
1410		1410
1411	error = gfs2_rindex_update(sdp);	1411	error = gfs2_rindex_update(sdp);
1412	if (error)	1412	if (error)
1413	return error;	1413	return error;
1414		1414
1415	rgd = gfs2_blk2rgrpd(sdp, ip->i_eattr, 1);	1415	rgd = gfs2_blk2rgrpd(sdp, ip->i_eattr, 1);
1416	if (!rgd) {	1416	if (!rgd) {
1417	gfs2_consist_inode(ip);	1417	gfs2_consist_inode(ip);
1418	return -EIO;	1418	return -EIO;
1419	}	1419	}
1420		1420
1421	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);	1421	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
1422	if (error)	1422	if (error)
1423	return error;	1423	return error;
1424		1424
1425	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_DINODE + RES_STATFS +	1425	error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_DINODE + RES_STATFS +
1426	RES_QUOTA, 1);	1426	RES_QUOTA, 1);
1427	if (error)	1427	if (error)
1428	goto out_gunlock;	1428	goto out_gunlock;
1429		1429
1430	gfs2_free_meta(ip, ip->i_eattr, 1);	1430	gfs2_free_meta(ip, ip->i_eattr, 1);
1431		1431
1432	ip->i_eattr = 0;	1432	ip->i_eattr = 0;
1433	gfs2_add_inode_blocks(&ip->i_inode, -1);	1433	gfs2_add_inode_blocks(&ip->i_inode, -1);
1434		1434
1435	error = gfs2_meta_inode_buffer(ip, &dibh);	1435	error = gfs2_meta_inode_buffer(ip, &dibh);
1436	if (!error) {	1436	if (!error) {
1437	gfs2_trans_add_bh(ip->i_gl, dibh, 1);	1437	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1438	gfs2_dinode_out(ip, dibh->b_data);	1438	gfs2_dinode_out(ip, dibh->b_data);
1439	brelse(dibh);	1439	brelse(dibh);
1440	}	1440	}
1441		1441
1442	gfs2_trans_end(sdp);	1442	gfs2_trans_end(sdp);
1443		1443
1444	out_gunlock:	1444	out_gunlock:
1445	gfs2_glock_dq_uninit(&gh);	1445	gfs2_glock_dq_uninit(&gh);
1446	return error;	1446	return error;
1447	}	1447	}
1448		1448
1449	/**	1449	/**
1450	* gfs2_ea_dealloc - deallocate the extended attribute fork	1450	* gfs2_ea_dealloc - deallocate the extended attribute fork
1451	* @ip: the inode	1451	* @ip: the inode
1452	*	1452	*
1453	* Returns: errno	1453	* Returns: errno
1454	*/	1454	*/
1455		1455
1456	int gfs2_ea_dealloc(struct gfs2_inode *ip)	1456	int gfs2_ea_dealloc(struct gfs2_inode *ip)
1457	{	1457	{
1458	int error;	1458	int error;
1459		1459
1460	error = gfs2_rindex_update(GFS2_SB(&ip->i_inode));	1460	error = gfs2_rindex_update(GFS2_SB(&ip->i_inode));
1461	if (error)	1461	if (error)
1462	return error;	1462	return error;
1463		1463
1464	error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);	1464	error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
1465	if (error)	1465	if (error)
1466	return error;	1466	return error;
1467		1467
1468	error = ea_foreach(ip, ea_dealloc_unstuffed, NULL);	1468	error = ea_foreach(ip, ea_dealloc_unstuffed, NULL);
1469	if (error)	1469	if (error)
1470	goto out_quota;	1470	goto out_quota;
1471		1471
1472	if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {	1472	if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
1473	error = ea_dealloc_indirect(ip);	1473	error = ea_dealloc_indirect(ip);
1474	if (error)	1474	if (error)
1475	goto out_quota;	1475	goto out_quota;
1476	}	1476	}
1477		1477
1478	error = ea_dealloc_block(ip);	1478	error = ea_dealloc_block(ip);
1479		1479
1480	out_quota:	1480	out_quota:
1481	gfs2_quota_unhold(ip);	1481	gfs2_quota_unhold(ip);
1482	return error;	1482	return error;
1483	}	1483	}
1484		1484
1485	static const struct xattr_handler gfs2_xattr_user_handler = {	1485	static const struct xattr_handler gfs2_xattr_user_handler = {
1486	.prefix = XATTR_USER_PREFIX,	1486	.prefix = XATTR_USER_PREFIX,
1487	.flags = GFS2_EATYPE_USR,	1487	.flags = GFS2_EATYPE_USR,
1488	.get = gfs2_xattr_get,	1488	.get = gfs2_xattr_get,
1489	.set = gfs2_xattr_set,	1489	.set = gfs2_xattr_set,
1490	};	1490	};
1491		1491
1492	static const struct xattr_handler gfs2_xattr_security_handler = {	1492	static const struct xattr_handler gfs2_xattr_security_handler = {
1493	.prefix = XATTR_SECURITY_PREFIX,	1493	.prefix = XATTR_SECURITY_PREFIX,
1494	.flags = GFS2_EATYPE_SECURITY,	1494	.flags = GFS2_EATYPE_SECURITY,
1495	.get = gfs2_xattr_get,	1495	.get = gfs2_xattr_get,
1496	.set = gfs2_xattr_set,	1496	.set = gfs2_xattr_set,
1497	};	1497	};
1498		1498
1499	const struct xattr_handler *gfs2_xattr_handlers[] = {	1499	const struct xattr_handler *gfs2_xattr_handlers[] = {
1500	&gfs2_xattr_user_handler,	1500	&gfs2_xattr_user_handler,
1501	&gfs2_xattr_security_handler,	1501	&gfs2_xattr_security_handler,
1502	&gfs2_xattr_system_handler,	1502	&gfs2_xattr_system_handler,
1503	NULL,	1503	NULL,
1504	};	1504	};
1505		1505
1506		1506