ops_address.c 21.1 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
53
54
55
56

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

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

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

83
84
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
85
86
87
{
	int error;

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

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

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

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

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

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

138
139
140
141
	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;
142
143
144
145
		if (!page_has_buffers(page)) {
			create_empty_buffers(page, inode->i_sb->s_blocksize,
					     (1 << BH_Dirty)|(1 << BH_Uptodate));
		}
146
147
148
		gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
		done_trans = 1;
	}
149
	error = block_write_full_page(page, gfs2_get_block_noalloc, wbc);
150
151
	if (done_trans)
		gfs2_trans_end(sdp);
David Teigland's avatar
David Teigland committed
152
153
	gfs2_meta_cache_flush(ip);
	return error;
154
155
156
157
158

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

161
162
163
164
165
166
167
168
169
170
171
172
173
/**
 * 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.
 */
174
175
static int gfs2_writepages(struct address_space *mapping,
			   struct writeback_control *wbc)
176
177
178
179
180
181
182
183
184
185
186
{
	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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
/**
 * 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;

201
202
203
204
205
206
207
208
209
210
211
212
213
	/*
	 * 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)) {
		kaddr = kmap_atomic(page, KM_USER0);
		memset(kaddr, 0, PAGE_CACHE_SIZE);
		kunmap_atomic(kaddr, KM_USER0);
		flush_dcache_page(page);
		SetPageUptodate(page);
		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_nopage 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
417
418
419
420
421
422
		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)) {
423
			error = gfs2_unstuff_dinode(ip, page);
424
425
426
			if (error == 0)
				goto prepare_write;
		} else if (!PageUptodate(page))
David Teigland's avatar
David Teigland committed
427
			error = stuffed_readpage(ip, page);
428
		goto out;
429
430
	}

431
prepare_write:
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
	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
449
450
451
452

	return error;
}

453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
/**
 * 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);
473
474
	fs_warn(sdp, "File system extended by %llu blocks.\n",
		(unsigned long long)new_free);
475
476
477
	gfs2_statfs_change(sdp, new_free, new_free, 0);
}

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

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

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

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

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

		SetPageUptodate(page);

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

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

540
541
542
	if (inode == sdp->sd_rindex)
		adjust_fs_space(inode);

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

556
557
558
559
560
561
562
563
564
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);
	}
565
	unlock_page(page);
566
	gfs2_glock_dq_m(1, &ip->i_gh);
567
	lock_page(page);
568
569
	gfs2_holder_uninit(&ip->i_gh);
fail_nounlock:
David Teigland's avatar
David Teigland committed
570
571
572
573
574
575
576
577
578
579
580
581
582
583
	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)
{
584
	struct gfs2_inode *ip = GFS2_I(mapping->host);
David Teigland's avatar
David Teigland committed
585
586
587
588
589
590
591
592
593
	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))
594
		dblock = generic_block_bmap(mapping, lblock, gfs2_get_block);
David Teigland's avatar
David Teigland committed
595
596
597
598
599
600
601
602

	gfs2_glock_dq_uninit(&i_gh);

	return dblock;
}

static void discard_buffer(struct gfs2_sbd *sdp, struct buffer_head *bh)
{
603
	struct gfs2_bufdata *bd;
David Teigland's avatar
David Teigland committed
604
605

	gfs2_log_lock(sdp);
606
	bd = bh->b_private;
607
608
	if (bd) {
		bd->bd_bh = NULL;
609
		bh->b_private = NULL;
610
611
	}
	gfs2_log_unlock(sdp);
David Teigland's avatar
David Teigland committed
612
613
614
615
616
617
618
619
620
621
622

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

623
static void gfs2_invalidatepage(struct page *page, unsigned long offset)
David Teigland's avatar
David Teigland committed
624
{
625
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
David Teigland's avatar
David Teigland committed
626
627
628
629
630
	struct buffer_head *head, *bh, *next;
	unsigned int curr_off = 0;

	BUG_ON(!PageLocked(page));
	if (!page_has_buffers(page))
631
		return;
David Teigland's avatar
David Teigland committed
632
633
634
635
636
637
638
639
640
641
642
643
644
645

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

648
	return;
David Teigland's avatar
David Teigland committed
649
650
}

Steven Whitehouse's avatar
Steven Whitehouse committed
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
/**
 * 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;
}



681
682
683
static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
			      const struct iovec *iov, loff_t offset,
			      unsigned long nr_segs)
684
685
686
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
687
	struct gfs2_inode *ip = GFS2_I(inode);
688
689
690
691
	struct gfs2_holder gh;
	int rv;

	/*
Steven Whitehouse's avatar
Steven Whitehouse committed
692
693
694
695
696
697
	 * 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.
698
	 */
Steven Whitehouse's avatar
Steven Whitehouse committed
699
	gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, GL_ATIME, &gh);
700
	rv = gfs2_glock_nq_atime(&gh);
701
	if (rv)
Steven Whitehouse's avatar
Steven Whitehouse committed
702
703
704
705
706
707
708
709
		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);
710
711
712
713
714
715
out:
	gfs2_glock_dq_m(1, &gh);
	gfs2_holder_uninit(&gh);
	return rv;
}

716
717
718
719
720
721
722
723
724
725
726
727
/**
 * 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;
728
729
static unsigned limit = 0;

730
	if (limit > 3)
731
		return;
732
	limit++;
733
734
735
736
737
738
739
740
741
742
743
744

	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;

745
	fs_warn(sdp, "gl = (%u, %llu)\n",
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
		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");
	}
}

/**
770
 * gfs2_releasepage - free the metadata associated with a page
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
 * @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;
786
	unsigned long t = jiffies + gfs2_tune_get(sdp, gt_stall_secs) * HZ;
787
788
789
790
791
792
793

	if (!page_has_buffers(page))
		goto out;

	head = bh = page_buffers(page);
	do {
		while (atomic_read(&bh->b_count)) {
794
795
796
			if (!atomic_read(&aspace->i_writecount))
				return 0;

797
798
799
			if (!(gfp_mask & __GFP_WAIT))
				return 0;

800
801
802
803
			if (time_after_eq(jiffies, t)) {
				stuck_releasepage(bh);
				/* should we withdraw here? */
				return 0;
804
805
			}

806
			yield();
807
808
809
		}

		gfs2_assert_warn(sdp, !buffer_pinned(bh));
810
		gfs2_assert_warn(sdp, !buffer_dirty(bh));
811

812
		gfs2_log_lock(sdp);
813
814
815
816
817
		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);
818
819
820
			bd->bd_bh = NULL;
			if (!list_empty(&bd->bd_le.le_list))
				bd = NULL;
821
822
			bh->b_private = NULL;
		}
823
824
825
		gfs2_log_unlock(sdp);
		if (bd)
			kmem_cache_free(gfs2_bufdata_cachep, bd);
826
827

		bh = bh->b_this_page;
828
	} while (bh != head);
829

830
out:
831
832
833
	return try_to_free_buffers(page);
}

834
const struct address_space_operations gfs2_file_aops = {
David Teigland's avatar
David Teigland committed
835
	.writepage = gfs2_writepage,
836
	.writepages = gfs2_writepages,
David Teigland's avatar
David Teigland committed
837
	.readpage = gfs2_readpage,
Steven Whitehouse's avatar
Steven Whitehouse committed
838
	.readpages = gfs2_readpages,
David Teigland's avatar
David Teigland committed
839
840
841
842
843
	.sync_page = block_sync_page,
	.prepare_write = gfs2_prepare_write,
	.commit_write = gfs2_commit_write,
	.bmap = gfs2_bmap,
	.invalidatepage = gfs2_invalidatepage,
844
	.releasepage = gfs2_releasepage,
David Teigland's avatar
David Teigland committed
845
846
847
	.direct_IO = gfs2_direct_IO,
};