ops_address.c 20.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-2007 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/writeback.h>
20
#include <linux/gfs2_ondisk.h>
21
#include <linux/lm_interface.h>
David Teigland's avatar
David Teigland committed
22
23

#include "gfs2.h"
24
#include "incore.h"
David Teigland's avatar
David Teigland committed
25
26
27
28
29
30
31
32
#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"
33
#include "rgrp.h"
34
#include "ops_file.h"
35
#include "super.h"
36
#include "util.h"
37
#include "glops.h"
David Teigland's avatar
David Teigland committed
38

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

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;
Benjamin Marzinski's avatar
Benjamin Marzinski committed
53
54
		if (gfs2_is_jdata(ip))
			set_buffer_uptodate(bh);
Steven Whitehouse's avatar
Steven Whitehouse committed
55
56
57
58
		gfs2_trans_add_bh(ip->i_gl, bh, 0);
	}
}

David Teigland's avatar
David Teigland committed
59
/**
60
 * gfs2_get_block - Fills in a buffer head with details about a block
David Teigland's avatar
David Teigland committed
61
62
63
64
65
66
67
68
 * @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
 */

69
70
int gfs2_get_block(struct inode *inode, sector_t lblock,
	           struct buffer_head *bh_result, int create)
David Teigland's avatar
David Teigland committed
71
{
72
	return gfs2_block_map(inode, lblock, create, bh_result);
David Teigland's avatar
David Teigland committed
73
74
75
}

/**
76
 * gfs2_get_block_noalloc - Fills in a buffer head with details about a block
David Teigland's avatar
David Teigland committed
77
78
79
80
81
82
83
84
 * @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
 */

85
86
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
87
88
89
{
	int error;

90
	error = gfs2_block_map(inode, lblock, 0, bh_result);
David Teigland's avatar
David Teigland committed
91
92
	if (error)
		return error;
Wendy Cheng's avatar
Wendy Cheng committed
93
	if (!buffer_mapped(bh_result))
94
95
		return -EIO;
	return 0;
David Teigland's avatar
David Teigland committed
96
97
}

98
99
static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,
				 struct buffer_head *bh_result, int create)
100
{
101
	return gfs2_block_map(inode, lblock, 0, bh_result);
102
}
103

David Teigland's avatar
David Teigland committed
104
105
106
107
108
109
/**
 * gfs2_writepage - Write complete page
 * @page: Page to write
 *
 * Returns: errno
 *
110
111
 * 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
112
113
114
115
 */

static int gfs2_writepage(struct page *page, struct writeback_control *wbc)
{
116
	struct inode *inode = page->mapping->host;
117
118
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
119
120
121
	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
122
	int error;
123
	int done_trans = 0;
David Teigland's avatar
David Teigland committed
124
125
126
127
128

	if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) {
		unlock_page(page);
		return -EIO;
	}
129
	if (current->journal_info)
130
131
132
133
		goto out_ignore;

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

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

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

165
166
167
168
169
170
171
172
173
174
175
176
177
/**
 * gfs2_writepages - Write a bunch of dirty pages back to disk
 * @mapping: The mapping to write
 * @wbc: Write-back control
 *
 * For journaled files and/or ordered writes this just falls back to the
 * kernel's default writepages path for now. We will probably want to change
 * that eventually (i.e. when we look at allocate on flush).
 *
 * For the data=writeback case though we can already ignore buffer heads
 * and write whole extents at once. This is a big reduction in the
 * number of I/O requests we send and the bmap calls we make in this case.
 */
178
179
static int gfs2_writepages(struct address_space *mapping,
			   struct writeback_control *wbc)
180
181
182
183
184
185
186
187
188
189
190
{
	struct inode *inode = mapping->host;
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);

	if (sdp->sd_args.ar_data == GFS2_DATA_WRITEBACK && !gfs2_is_jdata(ip))
		return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc);

	return generic_writepages(mapping, wbc);
}

David Teigland's avatar
David Teigland committed
191
192
193
194
195
196
197
198
199
200
201
202
203
204
/**
 * 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;

205
206
207
208
209
210
	/*
	 * Due to the order of unstuffing files and ->nopage(), we can be
	 * asked for a zero page in the case of a stuffed file being extended,
	 * so we need to supply one here. It doesn't happen often.
	 */
	if (unlikely(page->index)) {
211
		zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
212
213
		return 0;
	}
Steven Whitehouse's avatar
Steven Whitehouse committed
214

David Teigland's avatar
David Teigland committed
215
216
217
218
	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		return error;

219
	kaddr = kmap_atomic(page, KM_USER0);
Steven Whitehouse's avatar
Steven Whitehouse committed
220
	memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
David Teigland's avatar
David Teigland committed
221
	       ip->i_di.di_size);
Steven Whitehouse's avatar
Steven Whitehouse committed
222
	memset(kaddr + ip->i_di.di_size, 0, PAGE_CACHE_SIZE - ip->i_di.di_size);
223
	kunmap_atomic(kaddr, KM_USER0);
224
	flush_dcache_page(page);
David Teigland's avatar
David Teigland committed
225
226
227
228
229
230
231
232
233
	brelse(dibh);
	SetPageUptodate(page);

	return 0;
}


/**
 * gfs2_readpage - readpage with locking
234
235
 * @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
236
237
238
239
240
241
242
 * @page: The page to read
 *
 * Returns: errno
 */

static int gfs2_readpage(struct file *file, struct page *page)
{
243
244
	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
245
	struct gfs2_file *gf = NULL;
246
	struct gfs2_holder gh;
David Teigland's avatar
David Teigland committed
247
	int error;
248
	int do_unlock = 0;
David Teigland's avatar
David Teigland committed
249

250
	if (likely(file != &gfs2_internal_file_sentinel)) {
251
		if (file) {
252
			gf = file->private_data;
253
			if (test_bit(GFF_EXLOCK, &gf->f_flags))
254
				/* gfs2_sharewrite_fault has grabbed the ip->i_gl already */
255
256
				goto skip_lock;
		}
257
		gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME|LM_FLAG_TRY_1CB, &gh);
258
		do_unlock = 1;
259
		error = gfs2_glock_nq_atime(&gh);
Steven Whitehouse's avatar
Steven Whitehouse committed
260
		if (unlikely(error))
261
262
			goto out_unlock;
	}
David Teigland's avatar
David Teigland committed
263

264
skip_lock:
265
	if (gfs2_is_stuffed(ip)) {
Steven Whitehouse's avatar
Steven Whitehouse committed
266
267
		error = stuffed_readpage(ip, page);
		unlock_page(page);
David Teigland's avatar
David Teigland committed
268
	} else
269
		error = mpage_readpage(page, gfs2_get_block);
David Teigland's avatar
David Teigland committed
270
271
272
273

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

274
	if (do_unlock) {
275
276
277
		gfs2_glock_dq_m(1, &gh);
		gfs2_holder_uninit(&gh);
	}
278
out:
David Teigland's avatar
David Teigland committed
279
	return error;
280
281
out_unlock:
	unlock_page(page);
282
283
284
285
	if (error == GLR_TRYFAILED) {
		error = AOP_TRUNCATED_PAGE;
		yield();
	}
286
	if (do_unlock)
Steven Whitehouse's avatar
Steven Whitehouse committed
287
288
289
290
291
292
293
294
295
296
297
298
299
		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.
300
 * 2. We don't handle stuffed files here we let readpage do the honours.
Steven Whitehouse's avatar
Steven Whitehouse committed
301
302
303
304
305
306
307
308
309
 * 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;
310
311
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse's avatar
Steven Whitehouse committed
312
	struct gfs2_holder gh;
313
	int ret = 0;
314
	int do_unlock = 0;
Steven Whitehouse's avatar
Steven Whitehouse committed
315

316
	if (likely(file != &gfs2_internal_file_sentinel)) {
317
318
319
320
321
		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
322
		gfs2_holder_init(ip->i_gl, LM_ST_SHARED,
323
				 LM_FLAG_TRY_1CB|GL_ATIME, &gh);
324
		do_unlock = 1;
325
		ret = gfs2_glock_nq_atime(&gh);
326
		if (ret == GLR_TRYFAILED)
Steven Whitehouse's avatar
Steven Whitehouse committed
327
328
329
330
			goto out_noerror;
		if (unlikely(ret))
			goto out_unlock;
	}
331
skip_lock:
332
	if (!gfs2_is_stuffed(ip))
Steven Whitehouse's avatar
Steven Whitehouse committed
333
334
		ret = mpage_readpages(mapping, pages, nr_pages, gfs2_get_block);

335
	if (do_unlock) {
Steven Whitehouse's avatar
Steven Whitehouse committed
336
337
338
339
340
341
342
343
344
345
		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:
346
	if (do_unlock)
Steven Whitehouse's avatar
Steven Whitehouse committed
347
		gfs2_holder_uninit(&gh);
348
	goto out;
David Teigland's avatar
David Teigland committed
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
}

/**
 * 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)
{
364
365
	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
366
367
	unsigned int data_blocks, ind_blocks, rblocks;
	int alloc_required;
David Teigland's avatar
David Teigland committed
368
	int error = 0;
369
370
371
	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;
372
373
	unsigned int write_len = to - from;

David Teigland's avatar
David Teigland committed
374

375
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME|LM_FLAG_TRY_1CB, &ip->i_gh);
376
	error = gfs2_glock_nq_atime(&ip->i_gh);
377
	if (unlikely(error)) {
378
379
		if (error == GLR_TRYFAILED) {
			unlock_page(page);
380
			error = AOP_TRUNCATED_PAGE;
381
			yield();
382
		}
383
		goto out_uninit;
384
	}
David Teigland's avatar
David Teigland committed
385

386
	gfs2_write_calc_reserv(ip, write_len, &data_blocks, &ind_blocks);
387

388
	error = gfs2_write_alloc_required(ip, pos, write_len, &alloc_required);
389
390
	if (error)
		goto out_unlock;
David Teigland's avatar
David Teigland committed
391

392

393
	ip->i_alloc.al_requested = 0;
394
395
396
397
398
399
400
	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;

401
		error = gfs2_quota_check(ip, ip->i_inode.i_uid, ip->i_inode.i_gid);
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
		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;

417
418
	error = gfs2_trans_begin(sdp, rblocks,
				 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
419
	if (error)
420
		goto out_trans_fail;
421
422
423

	if (gfs2_is_stuffed(ip)) {
		if (end > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
424
			error = gfs2_unstuff_dinode(ip, page);
425
426
427
			if (error == 0)
				goto prepare_write;
		} else if (!PageUptodate(page))
David Teigland's avatar
David Teigland committed
428
			error = stuffed_readpage(ip, page);
429
		goto out;
430
431
	}

432
prepare_write:
433
434
435
436
437
	error = block_prepare_write(page, from, to, gfs2_get_block);

out:
	if (error) {
		gfs2_trans_end(sdp);
438
out_trans_fail:
439
440
441
442
443
444
445
446
447
448
449
450
		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
451
452
453
454

	return error;
}

455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
/**
 * adjust_fs_space - Adjusts the free space available due to gfs2_grow
 * @inode: the rindex inode
 */
static void adjust_fs_space(struct inode *inode)
{
	struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
	struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
	struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
	u64 fs_total, new_free;

	/* Total up the file system space, according to the latest rindex. */
	fs_total = gfs2_ri_total(sdp);

	spin_lock(&sdp->sd_statfs_spin);
	if (fs_total > (m_sc->sc_total + l_sc->sc_total))
		new_free = fs_total - (m_sc->sc_total + l_sc->sc_total);
	else
		new_free = 0;
	spin_unlock(&sdp->sd_statfs_spin);
475
476
	fs_warn(sdp, "File system extended by %llu blocks.\n",
		(unsigned long long)new_free);
477
478
479
	gfs2_statfs_change(sdp, new_free, new_free, 0);
}

David Teigland's avatar
David Teigland committed
480
481
482
483
484
485
486
487
488
489
490
491
492
493
/**
 * 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;
494
495
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
496
497
	int error = -EOPNOTSUPP;
	struct buffer_head *dibh;
498
499
	struct gfs2_alloc *al = &ip->i_alloc;
	struct gfs2_dinode *di;
David Teigland's avatar
David Teigland committed
500

501
502
503
504
505
506
507
508
	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);
509
	di = (struct gfs2_dinode *)dibh->b_data;
510

David Teigland's avatar
David Teigland committed
511
	if (gfs2_is_stuffed(ip)) {
512
		u64 file_size;
David Teigland's avatar
David Teigland committed
513
514
		void *kaddr;

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

517
		kaddr = kmap_atomic(page, KM_USER0);
David Teigland's avatar
David Teigland committed
518
		memcpy(dibh->b_data + sizeof(struct gfs2_dinode) + from,
519
		       kaddr + from, to - from);
520
		kunmap_atomic(kaddr, KM_USER0);
David Teigland's avatar
David Teigland committed
521
522
523

		SetPageUptodate(page);

524
		if (inode->i_size < file_size) {
David Teigland's avatar
David Teigland committed
525
			i_size_write(inode, file_size);
526
527
			mark_inode_dirty(inode);
		}
David Teigland's avatar
David Teigland committed
528
	} else {
529
530
		if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED ||
		    gfs2_is_jdata(ip))
531
			gfs2_page_add_databufs(ip, page, from, to);
David Teigland's avatar
David Teigland committed
532
533
534
535
536
		error = generic_commit_write(file, page, from, to);
		if (error)
			goto fail;
	}

537
	if (ip->i_di.di_size < inode->i_size) {
538
		ip->i_di.di_size = inode->i_size;
539
540
541
		di->di_size = cpu_to_be64(inode->i_size);
	}

542
543
544
	if (inode == sdp->sd_rindex)
		adjust_fs_space(inode);

545
546
547
548
549
550
551
	brelse(dibh);
	gfs2_trans_end(sdp);
	if (al->al_requested) {
		gfs2_inplace_release(ip);
		gfs2_quota_unlock(ip);
		gfs2_alloc_put(ip);
	}
552
	unlock_page(page);
553
	gfs2_glock_dq_m(1, &ip->i_gh);
554
	lock_page(page);
555
	gfs2_holder_uninit(&ip->i_gh);
David Teigland's avatar
David Teigland committed
556
557
	return 0;

558
559
560
561
562
563
564
565
566
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);
	}
567
	unlock_page(page);
568
	gfs2_glock_dq_m(1, &ip->i_gh);
569
	lock_page(page);
570
571
	gfs2_holder_uninit(&ip->i_gh);
fail_nounlock:
David Teigland's avatar
David Teigland committed
572
573
574
575
	ClearPageUptodate(page);
	return error;
}

576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
/**
 * gfs2_set_page_dirty - Page dirtying function
 * @page: The page to dirty
 *
 * Returns: 1 if it dirtyed the page, or 0 otherwise
 */
 
static int gfs2_set_page_dirty(struct page *page)
{
	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);

	if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip))
		SetPageChecked(page);
	return __set_page_dirty_buffers(page);
}

David Teigland's avatar
David Teigland committed
593
594
595
596
597
598
599
600
601
602
/**
 * 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)
{
603
	struct gfs2_inode *ip = GFS2_I(mapping->host);
David Teigland's avatar
David Teigland committed
604
605
606
607
608
609
610
611
612
	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))
613
		dblock = generic_block_bmap(mapping, lblock, gfs2_get_block);
David Teigland's avatar
David Teigland committed
614
615
616
617
618
619

	gfs2_glock_dq_uninit(&i_gh);

	return dblock;
}

620
621
622
623
624
625
626
627
628
static void gfs2_discard(struct gfs2_sbd *sdp, struct buffer_head *bh)
{
	struct gfs2_bufdata *bd;

	lock_buffer(bh);
	gfs2_log_lock(sdp);
	clear_buffer_dirty(bh);
	bd = bh->b_private;
	if (bd) {
629
630
631
632
		if (!list_empty(&bd->bd_le.le_list) && !buffer_pinned(bh))
			list_del_init(&bd->bd_le.le_list);
		else
			gfs2_remove_from_journal(bh, current->journal_info, 0);
633
634
635
636
637
638
639
640
641
	}
	bh->b_bdev = NULL;
	clear_buffer_mapped(bh);
	clear_buffer_req(bh);
	clear_buffer_new(bh);
	gfs2_log_unlock(sdp);
	unlock_buffer(bh);
}

642
static void gfs2_invalidatepage(struct page *page, unsigned long offset)
David Teigland's avatar
David Teigland committed
643
{
644
645
646
647
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
	struct buffer_head *bh, *head;
	unsigned long pos = 0;

David Teigland's avatar
David Teigland committed
648
	BUG_ON(!PageLocked(page));
649
650
	if (offset == 0)
		ClearPageChecked(page);
651
652
	if (!page_has_buffers(page))
		goto out;
David Teigland's avatar
David Teigland committed
653

654
655
656
657
658
659
660
661
662
663
	bh = head = page_buffers(page);
	do {
		if (offset <= pos)
			gfs2_discard(sdp, bh);
		pos += bh->b_size;
		bh = bh->b_this_page;
	} while (bh != head);
out:
	if (offset == 0)
		try_to_release_page(page, 0);
David Teigland's avatar
David Teigland committed
664
665
}

Steven Whitehouse's avatar
Steven Whitehouse committed
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
/**
 * 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;
}



696
697
698
static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
			      const struct iovec *iov, loff_t offset,
			      unsigned long nr_segs)
699
700
701
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
702
	struct gfs2_inode *ip = GFS2_I(inode);
703
704
705
706
	struct gfs2_holder gh;
	int rv;

	/*
Steven Whitehouse's avatar
Steven Whitehouse committed
707
708
709
710
711
712
	 * 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.
713
	 */
Steven Whitehouse's avatar
Steven Whitehouse committed
714
	gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, GL_ATIME, &gh);
715
	rv = gfs2_glock_nq_atime(&gh);
716
	if (rv)
Steven Whitehouse's avatar
Steven Whitehouse committed
717
718
719
720
721
722
723
724
		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);
725
726
727
728
729
730
out:
	gfs2_glock_dq_m(1, &gh);
	gfs2_holder_uninit(&gh);
	return rv;
}

731
/**
732
 * gfs2_releasepage - free the metadata associated with a page
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
 * @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;

	if (!page_has_buffers(page))
		goto out;

752
	gfs2_log_lock(sdp);
753
754
	head = bh = page_buffers(page);
	do {
755
756
757
758
759
		if (atomic_read(&bh->b_count))
			goto cannot_release;
		bd = bh->b_private;
		if (bd && bd->bd_ail)
			goto cannot_release;
760
		gfs2_assert_warn(sdp, !buffer_pinned(bh));
761
		gfs2_assert_warn(sdp, !buffer_dirty(bh));
762
763
764
		bh = bh->b_this_page;
	} while(bh != head);
	gfs2_log_unlock(sdp);
765

766
767
	head = bh = page_buffers(page);
	do {
768
		gfs2_log_lock(sdp);
769
770
771
772
		bd = bh->b_private;
		if (bd) {
			gfs2_assert_warn(sdp, bd->bd_bh == bh);
			gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));
773
774
775
776
777
778
779
780
			if (!list_empty(&bd->bd_le.le_list)) {
				if (!buffer_pinned(bh))
					list_del_init(&bd->bd_le.le_list);
				else
					bd = NULL;
			}
			if (bd)
				bd->bd_bh = NULL;
781
782
			bh->b_private = NULL;
		}
783
784
785
		gfs2_log_unlock(sdp);
		if (bd)
			kmem_cache_free(gfs2_bufdata_cachep, bd);
786
787

		bh = bh->b_this_page;
788
	} while (bh != head);
789

790
out:
791
	return try_to_free_buffers(page);
792
793
794
cannot_release:
	gfs2_log_unlock(sdp);
	return 0;
795
796
}

797
const struct address_space_operations gfs2_file_aops = {
David Teigland's avatar
David Teigland committed
798
	.writepage = gfs2_writepage,
799
	.writepages = gfs2_writepages,
David Teigland's avatar
David Teigland committed
800
	.readpage = gfs2_readpage,
Steven Whitehouse's avatar
Steven Whitehouse committed
801
	.readpages = gfs2_readpages,
David Teigland's avatar
David Teigland committed
802
803
804
	.sync_page = block_sync_page,
	.prepare_write = gfs2_prepare_write,
	.commit_write = gfs2_commit_write,
805
	.set_page_dirty = gfs2_set_page_dirty,
David Teigland's avatar
David Teigland committed
806
807
	.bmap = gfs2_bmap,
	.invalidatepage = gfs2_invalidatepage,
808
	.releasepage = gfs2_releasepage,
David Teigland's avatar
David Teigland committed
809
810
811
	.direct_IO = gfs2_direct_IO,
};