ops_address.c 18.7 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
}

Steven Whitehouse's avatar
Steven Whitehouse committed
159
160
161
162
163
164
static int zero_readpage(struct page *page)
{
	void *kaddr;

	kaddr = kmap_atomic(page, KM_USER0);
	memset(kaddr, 0, PAGE_CACHE_SIZE);
165
	kunmap_atomic(kaddr, KM_USER0);
Steven Whitehouse's avatar
Steven Whitehouse committed
166
167
168
169
170
171

	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(kaddr, 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
		ret = gfs2_glock_nq_m_atime(1, &gh);
299
		if (ret == GLR_TRYFAILED)
Steven Whitehouse's avatar
Steven Whitehouse committed
300
301
302
303
			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
		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:
340
	if (do_unlock)
Steven Whitehouse's avatar
Steven Whitehouse committed
341
		gfs2_holder_uninit(&gh);
342
	goto out;
David Teigland's avatar
David Teigland committed
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
}

/**
 * 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)
{
358
359
	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
360
361
	unsigned int data_blocks, ind_blocks, rblocks;
	int alloc_required;
David Teigland's avatar
David Teigland committed
362
	int error = 0;
363
364
365
	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;
366
367
	unsigned int write_len = to - from;

David Teigland's avatar
David Teigland committed
368

369
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME|GL_AOP, &ip->i_gh);
370
371
372
	error = gfs2_glock_nq_m_atime(1, &ip->i_gh);
	if (error)
		goto out_uninit;
David Teigland's avatar
David Teigland committed
373

374
	gfs2_write_calc_reserv(ip, write_len, &data_blocks, &ind_blocks);
375

376
	error = gfs2_write_alloc_required(ip, pos, write_len, &alloc_required);
377
378
	if (error)
		goto out_unlock;
David Teigland's avatar
David Teigland committed
379

380

381
	ip->i_alloc.al_requested = 0;
382
383
384
385
386
387
388
	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;

389
		error = gfs2_quota_check(ip, ip->i_inode.i_uid, ip->i_inode.i_gid);
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
		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)) {
411
			error = gfs2_unstuff_dinode(ip, page);
412
413
414
			if (error == 0)
				goto prepare_write;
		} else if (!PageUptodate(page))
David Teigland's avatar
David Teigland committed
415
			error = stuffed_readpage(ip, page);
416
		goto out;
417
418
	}

419
prepare_write:
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
	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
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454

	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;
455
456
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
457
458
	int error = -EOPNOTSUPP;
	struct buffer_head *dibh;
459
460
	struct gfs2_alloc *al = &ip->i_alloc;
	struct gfs2_dinode *di;
David Teigland's avatar
David Teigland committed
461

462
463
464
465
466
467
468
469
	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);
470
	di = (struct gfs2_dinode *)dibh->b_data;
471

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

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

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

		SetPageUptodate(page);

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

496
	if (ip->i_di.di_size < inode->i_size) {
497
		ip->i_di.di_size = inode->i_size;
498
499
500
		di->di_size = cpu_to_be64(inode->i_size);
	}

501
502
503
504
505
506
507
508
509
	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
510
511
	return 0;

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

	gfs2_glock_dq_uninit(&i_gh);

	return dblock;
}

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

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

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

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

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

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

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

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

615
616
	if (rw == READ)
		mutex_lock(&inode->i_mutex);
617
	/*
618
	 * Shared lock, even if its a write, since we do no allocation
619
620
621
622
623
624
625
	 * 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;

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

629
630
631
632
633
634
635
636
637
638
639
640
	/*
	 * 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;

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

	return rv;
}

654
655
656
657
658
659
660
661
662
663
664
665
/**
 * 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;
666
667
static unsigned limit = 0;

668
	if (limit > 3)
669
		return;
670
	limit++;
671
672
673
674
675
676
677
678
679
680
681
682

	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;

683
	fs_warn(sdp, "gl = (%u, %llu)\n",
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
		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");
	}
}

/**
708
 * gfs2_releasepage - free the metadata associated with a page
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
 * @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;
724
	unsigned long t = jiffies + gfs2_tune_get(sdp, gt_stall_secs) * HZ;
725
726
727
728
729
730
731

	if (!page_has_buffers(page))
		goto out;

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

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

741
			yield();
742
743
744
		}

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

747
		gfs2_log_lock(sdp);
748
749
750
751
752
		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);
753
754
755
			bd->bd_bh = NULL;
			if (!list_empty(&bd->bd_le.le_list))
				bd = NULL;
756
757
			bh->b_private = NULL;
		}
758
759
760
		gfs2_log_unlock(sdp);
		if (bd)
			kmem_cache_free(gfs2_bufdata_cachep, bd);
761
762

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

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

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