ops_address.c 18.9 KB
Newer Older
David Teigland's avatar
David Teigland committed
1
2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3
 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
David Teigland's avatar
David Teigland committed
4
5
6
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
7
 * of the GNU General Public License version 2.
David Teigland's avatar
David Teigland committed
8
9
10
11
12
13
14
15
 */

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/pagemap.h>
Steven Whitehouse's avatar
Steven Whitehouse committed
16
#include <linux/pagevec.h>
17
#include <linux/mpage.h>
18
#include <linux/fs.h>
19
#include <linux/gfs2_ondisk.h>
20
#include <linux/lm_interface.h>
David Teigland's avatar
David Teigland committed
21
22

#include "gfs2.h"
23
#include "incore.h"
David Teigland's avatar
David Teigland committed
24
25
26
27
28
29
30
31
#include "bmap.h"
#include "glock.h"
#include "inode.h"
#include "log.h"
#include "meta_io.h"
#include "ops_address.h"
#include "quota.h"
#include "trans.h"
32
#include "rgrp.h"
33
#include "ops_file.h"
34
#include "util.h"
35
#include "glops.h"
David Teigland's avatar
David Teigland committed
36

Steven Whitehouse's avatar
Steven Whitehouse committed
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

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

	for (bh = head, start = 0; bh != head || !start;
	     bh = bh->b_this_page, start = end) {
		end = start + bsize;
		if (end <= from || start >= to)
			continue;
		gfs2_trans_add_bh(ip->i_gl, bh, 0);
	}
}

David Teigland's avatar
David Teigland committed
55
/**
56
 * gfs2_get_block - Fills in a buffer head with details about a block
David Teigland's avatar
David Teigland committed
57
58
59
60
61
62
63
64
 * @inode: The inode
 * @lblock: The block number to look up
 * @bh_result: The buffer head to return the result in
 * @create: Non-zero if we may add block to the file
 *
 * Returns: errno
 */

65
66
int gfs2_get_block(struct inode *inode, sector_t lblock,
	           struct buffer_head *bh_result, int create)
David Teigland's avatar
David Teigland committed
67
{
68
	return gfs2_block_map(inode, lblock, create, bh_result, 4);
David Teigland's avatar
David Teigland committed
69
70
71
}

/**
72
 * gfs2_get_block_noalloc - Fills in a buffer head with details about a block
David Teigland's avatar
David Teigland committed
73
74
75
76
77
78
79
80
 * @inode: The inode
 * @lblock: The block number to look up
 * @bh_result: The buffer head to return the result in
 * @create: Non-zero if we may add block to the file
 *
 * Returns: errno
 */

81
82
static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,
				  struct buffer_head *bh_result, int create)
David Teigland's avatar
David Teigland committed
83
84
85
{
	int error;

86
	error = gfs2_block_map(inode, lblock, 0, bh_result, 1);
David Teigland's avatar
David Teigland committed
87
88
	if (error)
		return error;
89
90
91
	if (bh_result->b_blocknr == 0)
		return -EIO;
	return 0;
David Teigland's avatar
David Teigland committed
92
93
}

94
95
static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,
				 struct buffer_head *bh_result, int create)
96
{
97
	return gfs2_block_map(inode, lblock, 0, bh_result, 32);
98
}
99

David Teigland's avatar
David Teigland committed
100
101
102
103
104
105
/**
 * gfs2_writepage - Write complete page
 * @page: Page to write
 *
 * Returns: errno
 *
106
107
 * Some of this is copied from block_write_full_page() although we still
 * call it to do most of the work.
David Teigland's avatar
David Teigland committed
108
109
110
111
 */

static int gfs2_writepage(struct page *page, struct writeback_control *wbc)
{
112
	struct inode *inode = page->mapping->host;
113
114
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
115
116
117
	loff_t i_size = i_size_read(inode);
	pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
	unsigned offset;
David Teigland's avatar
David Teigland committed
118
	int error;
119
	int done_trans = 0;
David Teigland's avatar
David Teigland committed
120
121
122
123
124

	if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) {
		unlock_page(page);
		return -EIO;
	}
125
	if (current->journal_info)
126
127
128
129
		goto out_ignore;

	/* Is the page fully outside i_size? (truncate in progress) */
        offset = i_size & (PAGE_CACHE_SIZE-1);
130
	if (page->index > end_index || (page->index == end_index && !offset)) {
131
		page->mapping->a_ops->invalidatepage(page, 0);
David Teigland's avatar
David Teigland committed
132
		unlock_page(page);
133
		return 0; /* don't care */
David Teigland's avatar
David Teigland committed
134
135
	}

136
137
138
139
	if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip)) {
		error = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
		if (error)
			goto out_ignore;
140
141
142
143
		if (!page_has_buffers(page)) {
			create_empty_buffers(page, inode->i_sb->s_blocksize,
					     (1 << BH_Dirty)|(1 << BH_Uptodate));
		}
144
145
146
		gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
		done_trans = 1;
	}
147
	error = block_write_full_page(page, gfs2_get_block_noalloc, wbc);
148
149
	if (done_trans)
		gfs2_trans_end(sdp);
David Teigland's avatar
David Teigland committed
150
151
	gfs2_meta_cache_flush(ip);
	return error;
152
153
154
155
156

out_ignore:
	redirty_page_for_writepage(wbc, page);
	unlock_page(page);
	return 0;
David Teigland's avatar
David Teigland committed
157
158
}

Steven Whitehouse's avatar
Steven Whitehouse committed
159
160
161
162
163
164
165
166
167
168
169
170
171
static int zero_readpage(struct page *page)
{
	void *kaddr;

	kaddr = kmap_atomic(page, KM_USER0);
	memset(kaddr, 0, PAGE_CACHE_SIZE);
	kunmap_atomic(page, KM_USER0);

	SetPageUptodate(page);

	return 0;
}

David Teigland's avatar
David Teigland committed
172
173
174
175
176
177
178
179
180
181
182
183
184
185
/**
 * stuffed_readpage - Fill in a Linux page with stuffed file data
 * @ip: the inode
 * @page: the page
 *
 * Returns: errno
 */

static int stuffed_readpage(struct gfs2_inode *ip, struct page *page)
{
	struct buffer_head *dibh;
	void *kaddr;
	int error;

Steven Whitehouse's avatar
Steven Whitehouse committed
186
187
188
189
	/* Only the first page of a stuffed file might contain data */
	if (unlikely(page->index))
		return zero_readpage(page);

David Teigland's avatar
David Teigland committed
190
191
192
193
	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		return error;

194
	kaddr = kmap_atomic(page, KM_USER0);
Steven Whitehouse's avatar
Steven Whitehouse committed
195
	memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
David Teigland's avatar
David Teigland committed
196
	       ip->i_di.di_size);
Steven Whitehouse's avatar
Steven Whitehouse committed
197
	memset(kaddr + ip->i_di.di_size, 0, PAGE_CACHE_SIZE - ip->i_di.di_size);
198
	kunmap_atomic(page, KM_USER0);
David Teigland's avatar
David Teigland committed
199
200
201
202
203
204
205
206
207
208
209

	brelse(dibh);

	SetPageUptodate(page);

	return 0;
}


/**
 * gfs2_readpage - readpage with locking
210
211
 * @file: The file to read a page for. N.B. This may be NULL if we are
 * reading an internal file.
David Teigland's avatar
David Teigland committed
212
213
214
215
216
217
218
 * @page: The page to read
 *
 * Returns: errno
 */

static int gfs2_readpage(struct file *file, struct page *page)
{
219
220
	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
221
	struct gfs2_file *gf = NULL;
222
	struct gfs2_holder gh;
David Teigland's avatar
David Teigland committed
223
	int error;
224
	int do_unlock = 0;
David Teigland's avatar
David Teigland committed
225

226
	if (likely(file != &gfs2_internal_file_sentinel)) {
227
		if (file) {
228
			gf = file->private_data;
229
			if (test_bit(GFF_EXLOCK, &gf->f_flags))
230
				/* gfs2_sharewrite_nopage has grabbed the ip->i_gl already */
231
232
				goto skip_lock;
		}
233
		gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME|GL_AOP, &gh);
234
		do_unlock = 1;
235
		error = gfs2_glock_nq_m_atime(1, &gh);
Steven Whitehouse's avatar
Steven Whitehouse committed
236
		if (unlikely(error))
237
238
			goto out_unlock;
	}
David Teigland's avatar
David Teigland committed
239

240
skip_lock:
241
	if (gfs2_is_stuffed(ip)) {
Steven Whitehouse's avatar
Steven Whitehouse committed
242
243
		error = stuffed_readpage(ip, page);
		unlock_page(page);
David Teigland's avatar
David Teigland committed
244
	} else
245
		error = mpage_readpage(page, gfs2_get_block);
David Teigland's avatar
David Teigland committed
246
247
248
249

	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
		error = -EIO;

250
	if (do_unlock) {
251
252
253
		gfs2_glock_dq_m(1, &gh);
		gfs2_holder_uninit(&gh);
	}
254
out:
David Teigland's avatar
David Teigland committed
255
	return error;
256
257
out_unlock:
	unlock_page(page);
258
	if (do_unlock)
Steven Whitehouse's avatar
Steven Whitehouse committed
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
		gfs2_holder_uninit(&gh);
	goto out;
}

/**
 * gfs2_readpages - Read a bunch of pages at once
 *
 * Some notes:
 * 1. This is only for readahead, so we can simply ignore any things
 *    which are slightly inconvenient (such as locking conflicts between
 *    the page lock and the glock) and return having done no I/O. Its
 *    obviously not something we'd want to do on too regular a basis.
 *    Any I/O we ignore at this time will be done via readpage later.
 * 2. We have to handle stuffed files here too.
 * 3. mpage_readpages() does most of the heavy lifting in the common case.
 * 4. gfs2_get_block() is relied upon to set BH_Boundary in the right places.
 * 5. We use LM_FLAG_TRY_1CB here, effectively we then have lock-ahead as
 *    well as read-ahead.
 */
static int gfs2_readpages(struct file *file, struct address_space *mapping,
			  struct list_head *pages, unsigned nr_pages)
{
	struct inode *inode = mapping->host;
282
283
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse's avatar
Steven Whitehouse committed
284
285
286
	struct gfs2_holder gh;
	unsigned page_idx;
	int ret;
287
	int do_unlock = 0;
Steven Whitehouse's avatar
Steven Whitehouse committed
288

289
	if (likely(file != &gfs2_internal_file_sentinel)) {
290
291
292
293
294
		if (file) {
			struct gfs2_file *gf = file->private_data;
			if (test_bit(GFF_EXLOCK, &gf->f_flags))
				goto skip_lock;
		}
Steven Whitehouse's avatar
Steven Whitehouse committed
295
296
		gfs2_holder_init(ip->i_gl, LM_ST_SHARED,
				 LM_FLAG_TRY_1CB|GL_ATIME|GL_AOP, &gh);
297
		do_unlock = 1;
Steven Whitehouse's avatar
Steven Whitehouse committed
298
299
300
301
302
303
		ret = gfs2_glock_nq_m_atime(1, &gh);
		if (ret == GLR_TRYFAILED) 
			goto out_noerror;
		if (unlikely(ret))
			goto out_unlock;
	}
304
skip_lock:
Steven Whitehouse's avatar
Steven Whitehouse committed
305
306
307
308
	if (gfs2_is_stuffed(ip)) {
		struct pagevec lru_pvec;
		pagevec_init(&lru_pvec, 0);
		for (page_idx = 0; page_idx < nr_pages; page_idx++) {
309
310
			struct page *page = list_entry(pages->prev, struct page, lru);
			prefetchw(&page->flags);
Steven Whitehouse's avatar
Steven Whitehouse committed
311
312
313
314
315
316
317
			list_del(&page->lru);
			if (!add_to_page_cache(page, mapping,
					       page->index, GFP_KERNEL)) {
				ret = stuffed_readpage(ip, page);
				unlock_page(page);
				if (!pagevec_add(&lru_pvec, page))
					 __pagevec_lru_add(&lru_pvec);
318
319
			} else {
				page_cache_release(page);
Steven Whitehouse's avatar
Steven Whitehouse committed
320
321
322
323
324
325
326
327
328
			}
		}
		pagevec_lru_add(&lru_pvec);
		ret = 0;
	} else {
		/* What we really want to do .... */
		ret = mpage_readpages(mapping, pages, nr_pages, gfs2_get_block);
	}

329
	if (do_unlock) {
Steven Whitehouse's avatar
Steven Whitehouse committed
330
331
332
333
334
335
336
337
338
339
340
341
		gfs2_glock_dq_m(1, &gh);
		gfs2_holder_uninit(&gh);
	}
out:
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
		ret = -EIO;
	return ret;
out_noerror:
	ret = 0;
out_unlock:
	/* unlock all pages, we can't do any I/O right now */
	for (page_idx = 0; page_idx < nr_pages; page_idx++) {
342
		struct page *page = list_entry(pages->prev, struct page, lru);
Steven Whitehouse's avatar
Steven Whitehouse committed
343
344
345
346
		list_del(&page->lru);
		unlock_page(page);
		page_cache_release(page);
	}
347
	if (do_unlock)
Steven Whitehouse's avatar
Steven Whitehouse committed
348
		gfs2_holder_uninit(&gh);
349
	goto out;
David Teigland's avatar
David Teigland committed
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
}

/**
 * gfs2_prepare_write - Prepare to write a page to a file
 * @file: The file to write to
 * @page: The page which is to be prepared for writing
 * @from: From (byte range within page)
 * @to: To (byte range within page)
 *
 * Returns: errno
 */

static int gfs2_prepare_write(struct file *file, struct page *page,
			      unsigned from, unsigned to)
{
365
366
	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
367
368
	unsigned int data_blocks, ind_blocks, rblocks;
	int alloc_required;
David Teigland's avatar
David Teigland committed
369
	int error = 0;
370
371
372
	loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + from;
	loff_t end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
	struct gfs2_alloc *al;
David Teigland's avatar
David Teigland committed
373

374
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME|GL_AOP, &ip->i_gh);
375
376
377
	error = gfs2_glock_nq_m_atime(1, &ip->i_gh);
	if (error)
		goto out_uninit;
David Teigland's avatar
David Teigland committed
378

379
380
381
382
383
	gfs2_write_calc_reserv(ip, to - from, &data_blocks, &ind_blocks);

	error = gfs2_write_alloc_required(ip, pos, from - to, &alloc_required);
	if (error)
		goto out_unlock;
David Teigland's avatar
David Teigland committed
384

385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414

	if (alloc_required) {
		al = gfs2_alloc_get(ip);

		error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
		if (error)
			goto out_alloc_put;

		error = gfs2_quota_check(ip, ip->i_di.di_uid, ip->i_di.di_gid);
		if (error)
			goto out_qunlock;

		al->al_requested = data_blocks + ind_blocks;
		error = gfs2_inplace_reserve(ip);
		if (error)
			goto out_qunlock;
	}

	rblocks = RES_DINODE + ind_blocks;
	if (gfs2_is_jdata(ip))
		rblocks += data_blocks ? data_blocks : 1;
	if (ind_blocks || data_blocks)
		rblocks += RES_STATFS + RES_QUOTA;

	error = gfs2_trans_begin(sdp, rblocks, 0);
	if (error)
		goto out;

	if (gfs2_is_stuffed(ip)) {
		if (end > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
415
			error = gfs2_unstuff_dinode(ip, page);
416
417
418
			if (error == 0)
				goto prepare_write;
		} else if (!PageUptodate(page))
David Teigland's avatar
David Teigland committed
419
			error = stuffed_readpage(ip, page);
420
		goto out;
421
422
	}

423
prepare_write:
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
	error = block_prepare_write(page, from, to, gfs2_get_block);

out:
	if (error) {
		gfs2_trans_end(sdp);
		if (alloc_required) {
			gfs2_inplace_release(ip);
out_qunlock:
			gfs2_quota_unlock(ip);
out_alloc_put:
			gfs2_alloc_put(ip);
		}
out_unlock:
		gfs2_glock_dq_m(1, &ip->i_gh);
out_uninit:
		gfs2_holder_uninit(&ip->i_gh);
	}
David Teigland's avatar
David Teigland committed
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458

	return error;
}

/**
 * gfs2_commit_write - Commit write to a file
 * @file: The file to write to
 * @page: The page containing the data
 * @from: From (byte range within page)
 * @to: To (byte range within page)
 *
 * Returns: errno
 */

static int gfs2_commit_write(struct file *file, struct page *page,
			     unsigned from, unsigned to)
{
	struct inode *inode = page->mapping->host;
459
460
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
461
462
463
	int error = -EOPNOTSUPP;
	struct buffer_head *dibh;
	struct gfs2_alloc *al = &ip->i_alloc;;
David Teigland's avatar
David Teigland committed
464

465
466
467
468
469
470
471
472
473
	if (gfs2_assert_withdraw(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)))
                goto fail_nounlock;

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		goto fail_endtrans;

	gfs2_trans_add_bh(ip->i_gl, dibh, 1);

David Teigland's avatar
David Teigland committed
474
	if (gfs2_is_stuffed(ip)) {
475
		u64 file_size;
David Teigland's avatar
David Teigland committed
476
477
		void *kaddr;

478
		file_size = ((u64)page->index << PAGE_CACHE_SHIFT) + to;
David Teigland's avatar
David Teigland committed
479

480
		kaddr = kmap_atomic(page, KM_USER0);
David Teigland's avatar
David Teigland committed
481
		memcpy(dibh->b_data + sizeof(struct gfs2_dinode) + from,
482
		       kaddr + from, to - from);
483
		kunmap_atomic(page, KM_USER0);
David Teigland's avatar
David Teigland committed
484
485
486
487
488
489

		SetPageUptodate(page);

		if (inode->i_size < file_size)
			i_size_write(inode, file_size);
	} else {
490
491
		if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED ||
		    gfs2_is_jdata(ip))
492
			gfs2_page_add_databufs(ip, page, from, to);
David Teigland's avatar
David Teigland committed
493
494
495
496
497
		error = generic_commit_write(file, page, from, to);
		if (error)
			goto fail;
	}

498
499
500
501
502
503
504
505
506
507
508
509
510
	if (ip->i_di.di_size < inode->i_size)
		ip->i_di.di_size = inode->i_size;

	gfs2_dinode_out(&ip->i_di, dibh->b_data);
	brelse(dibh);
	gfs2_trans_end(sdp);
	if (al->al_requested) {
		gfs2_inplace_release(ip);
		gfs2_quota_unlock(ip);
		gfs2_alloc_put(ip);
	}
	gfs2_glock_dq_m(1, &ip->i_gh);
	gfs2_holder_uninit(&ip->i_gh);
David Teigland's avatar
David Teigland committed
511
512
	return 0;

513
514
515
516
517
518
519
520
521
522
523
524
fail:
	brelse(dibh);
fail_endtrans:
	gfs2_trans_end(sdp);
	if (al->al_requested) {
		gfs2_inplace_release(ip);
		gfs2_quota_unlock(ip);
		gfs2_alloc_put(ip);
	}
	gfs2_glock_dq_m(1, &ip->i_gh);
	gfs2_holder_uninit(&ip->i_gh);
fail_nounlock:
David Teigland's avatar
David Teigland committed
525
526
527
528
529
530
531
532
533
534
535
536
537
538
	ClearPageUptodate(page);
	return error;
}

/**
 * gfs2_bmap - Block map function
 * @mapping: Address space info
 * @lblock: The block to map
 *
 * Returns: The disk address for the block or 0 on hole or error
 */

static sector_t gfs2_bmap(struct address_space *mapping, sector_t lblock)
{
539
	struct gfs2_inode *ip = GFS2_I(mapping->host);
David Teigland's avatar
David Teigland committed
540
541
542
543
544
545
546
547
548
	struct gfs2_holder i_gh;
	sector_t dblock = 0;
	int error;

	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
	if (error)
		return 0;

	if (!gfs2_is_stuffed(ip))
549
		dblock = generic_block_bmap(mapping, lblock, gfs2_get_block);
David Teigland's avatar
David Teigland committed
550
551
552
553
554
555
556
557

	gfs2_glock_dq_uninit(&i_gh);

	return dblock;
}

static void discard_buffer(struct gfs2_sbd *sdp, struct buffer_head *bh)
{
558
	struct gfs2_bufdata *bd;
David Teigland's avatar
David Teigland committed
559
560

	gfs2_log_lock(sdp);
561
	bd = bh->b_private;
562
563
	if (bd) {
		bd->bd_bh = NULL;
564
		bh->b_private = NULL;
565
566
	}
	gfs2_log_unlock(sdp);
David Teigland's avatar
David Teigland committed
567
568
569
570
571
572
573
574
575
576
577

	lock_buffer(bh);
	clear_buffer_dirty(bh);
	bh->b_bdev = NULL;
	clear_buffer_mapped(bh);
	clear_buffer_req(bh);
	clear_buffer_new(bh);
	clear_buffer_delay(bh);
	unlock_buffer(bh);
}

578
static void gfs2_invalidatepage(struct page *page, unsigned long offset)
David Teigland's avatar
David Teigland committed
579
{
580
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
David Teigland's avatar
David Teigland committed
581
582
583
584
585
	struct buffer_head *head, *bh, *next;
	unsigned int curr_off = 0;

	BUG_ON(!PageLocked(page));
	if (!page_has_buffers(page))
586
		return;
David Teigland's avatar
David Teigland committed
587
588
589
590
591
592
593
594
595
596
597
598
599
600

	bh = head = page_buffers(page);
	do {
		unsigned int next_off = curr_off + bh->b_size;
		next = bh->b_this_page;

		if (offset <= curr_off)
			discard_buffer(sdp, bh);

		curr_off = next_off;
		bh = next;
	} while (bh != head);

	if (!offset)
601
		try_to_release_page(page, 0);
David Teigland's avatar
David Teigland committed
602

603
	return;
David Teigland's avatar
David Teigland committed
604
605
}

606
607
608
static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
			      const struct iovec *iov, loff_t offset,
			      unsigned long nr_segs)
609
610
611
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
612
	struct gfs2_inode *ip = GFS2_I(inode);
613
614
615
	struct gfs2_holder gh;
	int rv;

616
617
	if (rw == READ)
		mutex_lock(&inode->i_mutex);
618
	/*
619
	 * Shared lock, even if its a write, since we do no allocation
620
621
622
623
624
625
626
	 * on this path. All we need change is atime.
	 */
	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
	rv = gfs2_glock_nq_m_atime(1, &gh);
	if (rv)
		goto out;

627
628
629
	if (offset > i_size_read(inode))
		goto out;

630
631
632
633
634
635
636
637
638
639
640
641
	/*
	 * Should we return an error here? I can't see that O_DIRECT for
	 * a journaled file makes any sense. For now we'll silently fall
	 * back to buffered I/O, likewise we do the same for stuffed
	 * files since they are (a) small and (b) unaligned.
	 */
	if (gfs2_is_jdata(ip))
		goto out;

	if (gfs2_is_stuffed(ip))
		goto out;

642
643
644
	rv = blockdev_direct_IO_own_locking(rw, iocb, inode,
					    inode->i_sb->s_bdev,
					    iov, offset, nr_segs,
645
					    gfs2_get_block_direct, NULL);
646
647
648
out:
	gfs2_glock_dq_m(1, &gh);
	gfs2_holder_uninit(&gh);
649
650
	if (rw == READ)
		mutex_unlock(&inode->i_mutex);
651
652
653
654

	return rv;
}

655
656
657
658
659
660
661
662
663
664
665
666
/**
 * stuck_releasepage - We're stuck in gfs2_releasepage().  Print stuff out.
 * @bh: the buffer we're stuck on
 *
 */

static void stuck_releasepage(struct buffer_head *bh)
{
	struct inode *inode = bh->b_page->mapping->host;
	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
	struct gfs2_bufdata *bd = bh->b_private;
	struct gfs2_glock *gl;
667
668
static unsigned limit = 0;

669
	if (limit > 3)
670
		return;
671
	limit++;
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708

	fs_warn(sdp, "stuck in gfs2_releasepage() %p\n", inode);
	fs_warn(sdp, "blkno = %llu, bh->b_count = %d\n",
		(unsigned long long)bh->b_blocknr, atomic_read(&bh->b_count));
	fs_warn(sdp, "pinned = %u\n", buffer_pinned(bh));
	fs_warn(sdp, "bh->b_private = %s\n", (bd) ? "!NULL" : "NULL");

	if (!bd)
		return;

	gl = bd->bd_gl;

	fs_warn(sdp, "gl = (%u, %llu)\n", 
		gl->gl_name.ln_type, (unsigned long long)gl->gl_name.ln_number);

	fs_warn(sdp, "bd_list_tr = %s, bd_le.le_list = %s\n",
		(list_empty(&bd->bd_list_tr)) ? "no" : "yes",
		(list_empty(&bd->bd_le.le_list)) ? "no" : "yes");

	if (gl->gl_ops == &gfs2_inode_glops) {
		struct gfs2_inode *ip = gl->gl_object;
		unsigned int x;

		if (!ip)
			return;

		fs_warn(sdp, "ip = %llu %llu\n",
			(unsigned long long)ip->i_num.no_formal_ino,
			(unsigned long long)ip->i_num.no_addr);

		for (x = 0; x < GFS2_MAX_META_HEIGHT; x++)
			fs_warn(sdp, "ip->i_cache[%u] = %s\n",
				x, (ip->i_cache[x]) ? "!NULL" : "NULL");
	}
}

/**
709
 * gfs2_releasepage - free the metadata associated with a page
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
 * @page: the page that's being released
 * @gfp_mask: passed from Linux VFS, ignored by us
 *
 * Call try_to_free_buffers() if the buffers in this page can be
 * released.
 *
 * Returns: 0
 */

int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
{
	struct inode *aspace = page->mapping->host;
	struct gfs2_sbd *sdp = aspace->i_sb->s_fs_info;
	struct buffer_head *bh, *head;
	struct gfs2_bufdata *bd;
725
	unsigned long t = jiffies + gfs2_tune_get(sdp, gt_stall_secs) * HZ;
726
727
728
729
730
731
732

	if (!page_has_buffers(page))
		goto out;

	head = bh = page_buffers(page);
	do {
		while (atomic_read(&bh->b_count)) {
733
734
735
736
737
738
739
			if (!atomic_read(&aspace->i_writecount))
				return 0;

			if (time_after_eq(jiffies, t)) {
				stuck_releasepage(bh);
				/* should we withdraw here? */
				return 0;
740
741
			}

742
			yield();
743
744
745
		}

		gfs2_assert_warn(sdp, !buffer_pinned(bh));
746
		gfs2_assert_warn(sdp, !buffer_dirty(bh));
747

748
		gfs2_log_lock(sdp);
749
750
751
752
753
		bd = bh->b_private;
		if (bd) {
			gfs2_assert_warn(sdp, bd->bd_bh == bh);
			gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));
			gfs2_assert_warn(sdp, !bd->bd_ail);
754
755
756
			bd->bd_bh = NULL;
			if (!list_empty(&bd->bd_le.le_list))
				bd = NULL;
757
758
			bh->b_private = NULL;
		}
759
760
761
		gfs2_log_unlock(sdp);
		if (bd)
			kmem_cache_free(gfs2_bufdata_cachep, bd);
762
763

		bh = bh->b_this_page;
764
	} while (bh != head);
765

766
out:
767
768
769
	return try_to_free_buffers(page);
}

770
const struct address_space_operations gfs2_file_aops = {
David Teigland's avatar
David Teigland committed
771
772
	.writepage = gfs2_writepage,
	.readpage = gfs2_readpage,
Steven Whitehouse's avatar
Steven Whitehouse committed
773
	.readpages = gfs2_readpages,
David Teigland's avatar
David Teigland committed
774
775
776
777
778
	.sync_page = block_sync_page,
	.prepare_write = gfs2_prepare_write,
	.commit_write = gfs2_commit_write,
	.bmap = gfs2_bmap,
	.invalidatepage = gfs2_invalidatepage,
779
	.releasepage = gfs2_releasepage,
David Teigland's avatar
David Teigland committed
780
781
782
	.direct_IO = gfs2_direct_IO,
};