ops_address.c 19.3 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);
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);
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);
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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
}

/**
 * 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;

173
	BUG_ON(page->index);
Steven Whitehouse's avatar
Steven Whitehouse committed
174

David Teigland's avatar
David Teigland committed
175
176
177
178
	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		return error;

179
	kaddr = kmap_atomic(page, KM_USER0);
Steven Whitehouse's avatar
Steven Whitehouse committed
180
	memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
David Teigland's avatar
David Teigland committed
181
	       ip->i_di.di_size);
Steven Whitehouse's avatar
Steven Whitehouse committed
182
	memset(kaddr + ip->i_di.di_size, 0, PAGE_CACHE_SIZE - ip->i_di.di_size);
183
	kunmap_atomic(kaddr, KM_USER0);
David Teigland's avatar
David Teigland committed
184
185
186
187
188
189
190
191
192
193
194

	brelse(dibh);

	SetPageUptodate(page);

	return 0;
}


/**
 * gfs2_readpage - readpage with locking
195
196
 * @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
197
198
199
200
201
202
203
 * @page: The page to read
 *
 * Returns: errno
 */

static int gfs2_readpage(struct file *file, struct page *page)
{
204
205
	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
206
	struct gfs2_file *gf = NULL;
207
	struct gfs2_holder gh;
David Teigland's avatar
David Teigland committed
208
	int error;
209
	int do_unlock = 0;
David Teigland's avatar
David Teigland committed
210

211
	if (likely(file != &gfs2_internal_file_sentinel)) {
212
		if (file) {
213
			gf = file->private_data;
214
			if (test_bit(GFF_EXLOCK, &gf->f_flags))
215
				/* gfs2_sharewrite_nopage has grabbed the ip->i_gl already */
216
217
				goto skip_lock;
		}
218
		gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME|LM_FLAG_TRY_1CB, &gh);
219
		do_unlock = 1;
220
		error = gfs2_glock_nq_atime(&gh);
Steven Whitehouse's avatar
Steven Whitehouse committed
221
		if (unlikely(error))
222
223
			goto out_unlock;
	}
David Teigland's avatar
David Teigland committed
224

225
skip_lock:
226
	if (gfs2_is_stuffed(ip)) {
Steven Whitehouse's avatar
Steven Whitehouse committed
227
228
		error = stuffed_readpage(ip, page);
		unlock_page(page);
David Teigland's avatar
David Teigland committed
229
	} else
230
		error = mpage_readpage(page, gfs2_get_block);
David Teigland's avatar
David Teigland committed
231
232
233
234

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

235
	if (do_unlock) {
236
237
238
		gfs2_glock_dq_m(1, &gh);
		gfs2_holder_uninit(&gh);
	}
239
out:
David Teigland's avatar
David Teigland committed
240
	return error;
241
out_unlock:
242
243
	if (error == GLR_TRYFAILED)
		error = AOP_TRUNCATED_PAGE;
244
	unlock_page(page);
245
	if (do_unlock)
Steven Whitehouse's avatar
Steven Whitehouse committed
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
		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;
269
270
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse's avatar
Steven Whitehouse committed
271
272
273
	struct gfs2_holder gh;
	unsigned page_idx;
	int ret;
274
	int do_unlock = 0;
Steven Whitehouse's avatar
Steven Whitehouse committed
275

276
	if (likely(file != &gfs2_internal_file_sentinel)) {
277
278
279
280
281
		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
282
		gfs2_holder_init(ip->i_gl, LM_ST_SHARED,
283
				 LM_FLAG_TRY_1CB|GL_ATIME, &gh);
284
		do_unlock = 1;
285
		ret = gfs2_glock_nq_atime(&gh);
286
		if (ret == GLR_TRYFAILED)
Steven Whitehouse's avatar
Steven Whitehouse committed
287
288
289
290
			goto out_noerror;
		if (unlikely(ret))
			goto out_unlock;
	}
291
skip_lock:
Steven Whitehouse's avatar
Steven Whitehouse committed
292
293
294
295
	if (gfs2_is_stuffed(ip)) {
		struct pagevec lru_pvec;
		pagevec_init(&lru_pvec, 0);
		for (page_idx = 0; page_idx < nr_pages; page_idx++) {
296
297
			struct page *page = list_entry(pages->prev, struct page, lru);
			prefetchw(&page->flags);
Steven Whitehouse's avatar
Steven Whitehouse committed
298
299
300
301
302
303
304
			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);
305
306
			} else {
				page_cache_release(page);
Steven Whitehouse's avatar
Steven Whitehouse committed
307
308
309
310
311
312
313
314
315
			}
		}
		pagevec_lru_add(&lru_pvec);
		ret = 0;
	} else {
		/* What we really want to do .... */
		ret = mpage_readpages(mapping, pages, nr_pages, gfs2_get_block);
	}

316
	if (do_unlock) {
Steven Whitehouse's avatar
Steven Whitehouse committed
317
318
319
320
321
322
323
324
325
326
		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:
327
	if (do_unlock)
Steven Whitehouse's avatar
Steven Whitehouse committed
328
		gfs2_holder_uninit(&gh);
329
	goto out;
David Teigland's avatar
David Teigland committed
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
}

/**
 * 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)
{
345
346
	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
347
348
	unsigned int data_blocks, ind_blocks, rblocks;
	int alloc_required;
David Teigland's avatar
David Teigland committed
349
	int error = 0;
350
351
352
	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;
353
354
	unsigned int write_len = to - from;

David Teigland's avatar
David Teigland committed
355

356
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME|LM_FLAG_TRY_1CB, &ip->i_gh);
357
	error = gfs2_glock_nq_atime(&ip->i_gh);
358
359
360
	if (unlikely(error)) {
		if (error == GLR_TRYFAILED)
			error = AOP_TRUNCATED_PAGE;
361
		goto out_uninit;
362
	}
David Teigland's avatar
David Teigland committed
363

364
	gfs2_write_calc_reserv(ip, write_len, &data_blocks, &ind_blocks);
365

366
	error = gfs2_write_alloc_required(ip, pos, write_len, &alloc_required);
367
368
	if (error)
		goto out_unlock;
David Teigland's avatar
David Teigland committed
369

370

371
	ip->i_alloc.al_requested = 0;
372
373
374
375
376
377
378
	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;

379
		error = gfs2_quota_check(ip, ip->i_inode.i_uid, ip->i_inode.i_gid);
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
		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)) {
401
			error = gfs2_unstuff_dinode(ip, page);
402
403
404
			if (error == 0)
				goto prepare_write;
		} else if (!PageUptodate(page))
David Teigland's avatar
David Teigland committed
405
			error = stuffed_readpage(ip, page);
406
		goto out;
407
408
	}

409
prepare_write:
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
	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
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444

	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;
445
446
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
447
448
	int error = -EOPNOTSUPP;
	struct buffer_head *dibh;
449
450
	struct gfs2_alloc *al = &ip->i_alloc;
	struct gfs2_dinode *di;
David Teigland's avatar
David Teigland committed
451

452
453
454
455
456
457
458
459
	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);
460
	di = (struct gfs2_dinode *)dibh->b_data;
461

David Teigland's avatar
David Teigland committed
462
	if (gfs2_is_stuffed(ip)) {
463
		u64 file_size;
David Teigland's avatar
David Teigland committed
464
465
		void *kaddr;

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

468
		kaddr = kmap_atomic(page, KM_USER0);
David Teigland's avatar
David Teigland committed
469
		memcpy(dibh->b_data + sizeof(struct gfs2_dinode) + from,
470
		       kaddr + from, to - from);
471
		kunmap_atomic(kaddr, KM_USER0);
David Teigland's avatar
David Teigland committed
472
473
474

		SetPageUptodate(page);

475
		if (inode->i_size < file_size) {
David Teigland's avatar
David Teigland committed
476
			i_size_write(inode, file_size);
477
478
			mark_inode_dirty(inode);
		}
David Teigland's avatar
David Teigland committed
479
	} else {
480
481
		if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED ||
		    gfs2_is_jdata(ip))
482
			gfs2_page_add_databufs(ip, page, from, to);
David Teigland's avatar
David Teigland committed
483
484
485
486
487
		error = generic_commit_write(file, page, from, to);
		if (error)
			goto fail;
	}

488
	if (ip->i_di.di_size < inode->i_size) {
489
		ip->i_di.di_size = inode->i_size;
490
491
492
		di->di_size = cpu_to_be64(inode->i_size);
	}

493
494
495
496
497
498
499
500
501
	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
502
503
	return 0;

504
505
506
507
508
509
510
511
512
513
514
515
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
516
517
518
519
520
521
522
523
524
525
526
527
528
529
	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)
{
530
	struct gfs2_inode *ip = GFS2_I(mapping->host);
David Teigland's avatar
David Teigland committed
531
532
533
534
535
536
537
538
539
	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))
540
		dblock = generic_block_bmap(mapping, lblock, gfs2_get_block);
David Teigland's avatar
David Teigland committed
541
542
543
544
545
546
547
548

	gfs2_glock_dq_uninit(&i_gh);

	return dblock;
}

static void discard_buffer(struct gfs2_sbd *sdp, struct buffer_head *bh)
{
549
	struct gfs2_bufdata *bd;
David Teigland's avatar
David Teigland committed
550
551

	gfs2_log_lock(sdp);
552
	bd = bh->b_private;
553
554
	if (bd) {
		bd->bd_bh = NULL;
555
		bh->b_private = NULL;
556
557
	}
	gfs2_log_unlock(sdp);
David Teigland's avatar
David Teigland committed
558
559
560
561
562
563
564
565
566
567
568

	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);
}

569
static void gfs2_invalidatepage(struct page *page, unsigned long offset)
David Teigland's avatar
David Teigland committed
570
{
571
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
David Teigland's avatar
David Teigland committed
572
573
574
575
576
	struct buffer_head *head, *bh, *next;
	unsigned int curr_off = 0;

	BUG_ON(!PageLocked(page));
	if (!page_has_buffers(page))
577
		return;
David Teigland's avatar
David Teigland committed
578
579
580
581
582
583
584
585
586
587
588
589
590
591

	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)
592
		try_to_release_page(page, 0);
David Teigland's avatar
David Teigland committed
593

594
	return;
David Teigland's avatar
David Teigland committed
595
596
}

Steven Whitehouse's avatar
Steven Whitehouse committed
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
/**
 * gfs2_ok_for_dio - check that dio is valid on this file
 * @ip: The inode
 * @rw: READ or WRITE
 * @offset: The offset at which we are reading or writing
 *
 * Returns: 0 (to ignore the i/o request and thus fall back to buffered i/o)
 *          1 (to accept the i/o request)
 */
static int gfs2_ok_for_dio(struct gfs2_inode *ip, int rw, loff_t offset)
{
	/*
	 * 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))
		return 0;

	if (gfs2_is_stuffed(ip))
		return 0;

	if (offset > i_size_read(&ip->i_inode))
		return 0;
	return 1;
}



627
628
629
static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
			      const struct iovec *iov, loff_t offset,
			      unsigned long nr_segs)
630
631
632
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
633
	struct gfs2_inode *ip = GFS2_I(inode);
634
635
636
637
	struct gfs2_holder gh;
	int rv;

	/*
Steven Whitehouse's avatar
Steven Whitehouse committed
638
639
640
641
642
643
	 * Deferred lock, even if its a write, since we do no allocation
	 * on this path. All we need change is atime, and this lock mode
	 * ensures that other nodes have flushed their buffered read caches
	 * (i.e. their page cache entries for this inode). We do not,
	 * unfortunately have the option of only flushing a range like
	 * the VFS does.
644
	 */
Steven Whitehouse's avatar
Steven Whitehouse committed
645
	gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, GL_ATIME, &gh);
646
	rv = gfs2_glock_nq_atime(&gh);
647
	if (rv)
Steven Whitehouse's avatar
Steven Whitehouse committed
648
649
650
651
652
653
654
655
		return rv;
	rv = gfs2_ok_for_dio(ip, rw, offset);
	if (rv != 1)
		goto out; /* dio not valid, fall back to buffered i/o */

	rv = blockdev_direct_IO_no_locking(rw, iocb, inode, inode->i_sb->s_bdev,
					   iov, offset, nr_segs,
					   gfs2_get_block_direct, NULL);
656
657
658
659
660
661
out:
	gfs2_glock_dq_m(1, &gh);
	gfs2_holder_uninit(&gh);
	return rv;
}

662
663
664
665
666
667
668
669
670
671
672
673
/**
 * 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;
674
675
static unsigned limit = 0;

676
	if (limit > 3)
677
		return;
678
	limit++;
679
680
681
682
683
684
685
686
687
688
689
690

	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;

691
	fs_warn(sdp, "gl = (%u, %llu)\n",
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
		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");
	}
}

/**
716
 * gfs2_releasepage - free the metadata associated with a page
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
 * @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;
732
	unsigned long t = jiffies + gfs2_tune_get(sdp, gt_stall_secs) * HZ;
733
734
735
736
737
738
739

	if (!page_has_buffers(page))
		goto out;

	head = bh = page_buffers(page);
	do {
		while (atomic_read(&bh->b_count)) {
740
741
742
			if (!atomic_read(&aspace->i_writecount))
				return 0;

743
744
745
			if (!(gfp_mask & __GFP_WAIT))
				return 0;

746
747
748
749
			if (time_after_eq(jiffies, t)) {
				stuck_releasepage(bh);
				/* should we withdraw here? */
				return 0;
750
751
			}

752
			yield();
753
754
755
		}

		gfs2_assert_warn(sdp, !buffer_pinned(bh));
756
		gfs2_assert_warn(sdp, !buffer_dirty(bh));
757

758
		gfs2_log_lock(sdp);
759
760
761
762
763
		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);
764
765
766
			bd->bd_bh = NULL;
			if (!list_empty(&bd->bd_le.le_list))
				bd = NULL;
767
768
			bh->b_private = NULL;
		}
769
770
771
		gfs2_log_unlock(sdp);
		if (bd)
			kmem_cache_free(gfs2_bufdata_cachep, bd);
772
773

		bh = bh->b_this_page;
774
	} while (bh != head);
775

776
out:
777
778
779
	return try_to_free_buffers(page);
}

780
const struct address_space_operations gfs2_file_aops = {
David Teigland's avatar
David Teigland committed
781
782
	.writepage = gfs2_writepage,
	.readpage = gfs2_readpage,
Steven Whitehouse's avatar
Steven Whitehouse committed
783
	.readpages = gfs2_readpages,
David Teigland's avatar
David Teigland committed
784
785
786
787
788
	.sync_page = block_sync_page,
	.prepare_write = gfs2_prepare_write,
	.commit_write = gfs2_commit_write,
	.bmap = gfs2_bmap,
	.invalidatepage = gfs2_invalidatepage,
789
	.releasepage = gfs2_releasepage,
David Teigland's avatar
David Teigland committed
790
791
792
	.direct_IO = gfs2_direct_IO,
};