ops_address.c 23.2 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>
Steven Whitehouse's avatar
Steven Whitehouse committed
20
#include <linux/swap.h>
21
#include <linux/gfs2_ondisk.h>
22
#include <linux/lm_interface.h>
23
#include <linux/swap.h>
David Teigland's avatar
David Teigland committed
24
25

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

206
207
208
209
210
211
	/*
	 * 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)) {
212
		zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
213
214
		return 0;
	}
Steven Whitehouse's avatar
Steven Whitehouse committed
215

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

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

	return 0;
}


/**
234
235
 * __gfs2_readpage - readpage
 * @file: The file to read a page for
David Teigland's avatar
David Teigland committed
236
237
 * @page: The page to read
 *
238
239
240
241
 * This is the core of gfs2's readpage. Its used by the internal file
 * reading code as in that case we already hold the glock. Also its
 * called by gfs2_readpage() once the required lock has been granted.
 *
David Teigland's avatar
David Teigland committed
242
243
 */

244
static int __gfs2_readpage(void *file, struct page *page)
David Teigland's avatar
David Teigland committed
245
{
246
247
	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
David Teigland's avatar
David Teigland committed
248
249
	int error;

250
	if (gfs2_is_stuffed(ip)) {
Steven Whitehouse's avatar
Steven Whitehouse committed
251
252
		error = stuffed_readpage(ip, page);
		unlock_page(page);
253
	} else {
254
		error = mpage_readpage(page, gfs2_get_block);
255
	}
David Teigland's avatar
David Teigland committed
256
257

	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
258
		return -EIO;
David Teigland's avatar
David Teigland committed
259

260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
	return error;
}

/**
 * gfs2_readpage - read a page of a file
 * @file: The file to read
 * @page: The page of the file
 *
 * This deals with the locking required. If the GFF_EXLOCK flags is set
 * then we already hold the glock (due to page fault) and thus we call
 * __gfs2_readpage() directly. Otherwise we use a trylock in order to
 * avoid the page lock / glock ordering problems returning AOP_TRUNCATED_PAGE
 * in the event that we are unable to get the lock.
 */

static int gfs2_readpage(struct file *file, struct page *page)
{
	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
	struct gfs2_holder gh;
	int error;

	if (file) {
		struct gfs2_file *gf = file->private_data;
		if (test_bit(GFF_EXLOCK, &gf->f_flags))
			return __gfs2_readpage(file, page);
	}

	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME|LM_FLAG_TRY_1CB, &gh);
	error = gfs2_glock_nq_atime(&gh);
	if (unlikely(error)) {
		unlock_page(page);
		goto out;
292
	}
293
294
	error = __gfs2_readpage(file, page);
	gfs2_glock_dq(&gh);
295
out:
296
	gfs2_holder_uninit(&gh);
297
298
	if (error == GLR_TRYFAILED) {
		yield();
299
		return AOP_TRUNCATED_PAGE;
300
	}
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
	return error;
}

/**
 * gfs2_internal_read - read an internal file
 * @ip: The gfs2 inode
 * @ra_state: The readahead state (or NULL for no readahead)
 * @buf: The buffer to fill
 * @pos: The file position
 * @size: The amount to read
 *
 */

int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,
                       char *buf, loff_t *pos, unsigned size)
{
	struct address_space *mapping = ip->i_inode.i_mapping;
	unsigned long index = *pos / PAGE_CACHE_SIZE;
	unsigned offset = *pos & (PAGE_CACHE_SIZE - 1);
	unsigned copied = 0;
	unsigned amt;
	struct page *page;
	void *p;

	do {
		amt = size - copied;
		if (offset + size > PAGE_CACHE_SIZE)
			amt = PAGE_CACHE_SIZE - offset;
		page = read_cache_page(mapping, index, __gfs2_readpage, NULL);
		if (IS_ERR(page))
			return PTR_ERR(page);
		p = kmap_atomic(page, KM_USER0);
		memcpy(buf + copied, p + offset, amt);
		kunmap_atomic(p, KM_USER0);
		mark_page_accessed(page);
		page_cache_release(page);
		copied += amt;
		index++;
		offset = 0;
	} while(copied < size);
	(*pos) += size;
	return size;
Steven Whitehouse's avatar
Steven Whitehouse committed
343
344
345
346
347
348
349
350
351
352
353
}

/**
 * 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.
354
 * 2. We don't handle stuffed files here we let readpage do the honours.
Steven Whitehouse's avatar
Steven Whitehouse committed
355
356
357
358
359
360
361
362
363
 * 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;
364
365
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse's avatar
Steven Whitehouse committed
366
	struct gfs2_holder gh;
367
	int ret = 0;
368
	int do_unlock = 0;
Steven Whitehouse's avatar
Steven Whitehouse committed
369

370
371
372
373
	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
374
	}
375
376
377
378
379
380
381
382
	gfs2_holder_init(ip->i_gl, LM_ST_SHARED,
			 LM_FLAG_TRY_1CB|GL_ATIME, &gh);
	do_unlock = 1;
	ret = gfs2_glock_nq_atime(&gh);
	if (ret == GLR_TRYFAILED)
		goto out_noerror;
	if (unlikely(ret))
		goto out_unlock;
383
skip_lock:
384
	if (!gfs2_is_stuffed(ip))
Steven Whitehouse's avatar
Steven Whitehouse committed
385
386
		ret = mpage_readpages(mapping, pages, nr_pages, gfs2_get_block);

387
	if (do_unlock) {
Steven Whitehouse's avatar
Steven Whitehouse committed
388
389
390
391
392
393
394
395
396
397
		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:
398
	if (do_unlock)
Steven Whitehouse's avatar
Steven Whitehouse committed
399
		gfs2_holder_uninit(&gh);
400
	goto out;
David Teigland's avatar
David Teigland committed
401
402
403
}

/**
Steven Whitehouse's avatar
Steven Whitehouse committed
404
 * gfs2_write_begin - Begin to write to a file
David Teigland's avatar
David Teigland committed
405
 * @file: The file to write to
Steven Whitehouse's avatar
Steven Whitehouse committed
406
407
408
409
410
411
 * @mapping: The mapping in which to write
 * @pos: The file offset at which to start writing
 * @len: Length of the write
 * @flags: Various flags
 * @pagep: Pointer to return the page
 * @fsdata: Pointer to return fs data (unused by GFS2)
David Teigland's avatar
David Teigland committed
412
413
414
415
 *
 * Returns: errno
 */

Steven Whitehouse's avatar
Steven Whitehouse committed
416
417
418
static int gfs2_write_begin(struct file *file, struct address_space *mapping,
			    loff_t pos, unsigned len, unsigned flags,
			    struct page **pagep, void **fsdata)
David Teigland's avatar
David Teigland committed
419
{
Steven Whitehouse's avatar
Steven Whitehouse committed
420
421
	struct gfs2_inode *ip = GFS2_I(mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);
422
423
	unsigned int data_blocks, ind_blocks, rblocks;
	int alloc_required;
David Teigland's avatar
David Teigland committed
424
	int error = 0;
425
	struct gfs2_alloc *al;
Steven Whitehouse's avatar
Steven Whitehouse committed
426
427
428
429
	pgoff_t index = pos >> PAGE_CACHE_SHIFT;
	unsigned from = pos & (PAGE_CACHE_SIZE - 1);
	unsigned to = from + len;
	struct page *page;
430

Steven Whitehouse's avatar
Steven Whitehouse committed
431
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME, &ip->i_gh);
432
	error = gfs2_glock_nq_atime(&ip->i_gh);
Steven Whitehouse's avatar
Steven Whitehouse committed
433
	if (unlikely(error))
434
		goto out_uninit;
David Teigland's avatar
David Teigland committed
435

Steven Whitehouse's avatar
Steven Whitehouse committed
436
437
438
439
440
441
442
	error = -ENOMEM;
	page = __grab_cache_page(mapping, index);
	*pagep = page;
	if (!page)
		goto out_unlock;

	gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks);
443

Steven Whitehouse's avatar
Steven Whitehouse committed
444
	error = gfs2_write_alloc_required(ip, pos, len, &alloc_required);
445
	if (error)
Steven Whitehouse's avatar
Steven Whitehouse committed
446
		goto out_putpage;
David Teigland's avatar
David Teigland committed
447

448

449
	ip->i_alloc.al_requested = 0;
450
451
452
453
454
455
456
	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;

457
		error = gfs2_quota_check(ip, ip->i_inode.i_uid, ip->i_inode.i_gid);
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
		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;

473
474
	error = gfs2_trans_begin(sdp, rblocks,
				 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
475
	if (error)
476
		goto out_trans_fail;
477
478

	if (gfs2_is_stuffed(ip)) {
Steven Whitehouse's avatar
Steven Whitehouse committed
479
		if (pos + len > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
480
			error = gfs2_unstuff_dinode(ip, page);
481
482
483
			if (error == 0)
				goto prepare_write;
		} else if (!PageUptodate(page))
David Teigland's avatar
David Teigland committed
484
			error = stuffed_readpage(ip, page);
485
		goto out;
486
487
	}

488
prepare_write:
489
490
491
492
493
	error = block_prepare_write(page, from, to, gfs2_get_block);

out:
	if (error) {
		gfs2_trans_end(sdp);
494
out_trans_fail:
495
496
497
498
499
500
501
		if (alloc_required) {
			gfs2_inplace_release(ip);
out_qunlock:
			gfs2_quota_unlock(ip);
out_alloc_put:
			gfs2_alloc_put(ip);
		}
Steven Whitehouse's avatar
Steven Whitehouse committed
502
503
504
505
out_putpage:
		page_cache_release(page);
		if (pos + len > ip->i_inode.i_size)
			vmtruncate(&ip->i_inode, ip->i_inode.i_size);
506
507
508
509
510
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
511
512
513
514

	return error;
}

515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
/**
 * 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);
535
536
	fs_warn(sdp, "File system extended by %llu blocks.\n",
		(unsigned long long)new_free);
537
538
539
	gfs2_statfs_change(sdp, new_free, new_free, 0);
}

David Teigland's avatar
David Teigland committed
540
/**
Steven Whitehouse's avatar
Steven Whitehouse committed
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
 * gfs2_stuffed_write_end - Write end for stuffed files
 * @inode: The inode
 * @dibh: The buffer_head containing the on-disk inode
 * @pos: The file position
 * @len: The length of the write
 * @copied: How much was actually copied by the VFS
 * @page: The page
 *
 * This copies the data from the page into the inode block after
 * the inode data structure itself.
 *
 * Returns: errno
 */
static int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh,
				  loff_t pos, unsigned len, unsigned copied,
				  struct page *page)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	u64 to = pos + copied;
	void *kaddr;
	unsigned char *buf = dibh->b_data + sizeof(struct gfs2_dinode);
	struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;

	BUG_ON((pos + len) > (dibh->b_size - sizeof(struct gfs2_dinode)));
	kaddr = kmap_atomic(page, KM_USER0);
	memcpy(buf + pos, kaddr + pos, copied);
	memset(kaddr + pos + copied, 0, len - copied);
	flush_dcache_page(page);
	kunmap_atomic(kaddr, KM_USER0);

	if (!PageUptodate(page))
		SetPageUptodate(page);
	unlock_page(page);
	page_cache_release(page);

	if (inode->i_size < to) {
		i_size_write(inode, to);
		ip->i_di.di_size = inode->i_size;
		di->di_size = cpu_to_be64(inode->i_size);
		mark_inode_dirty(inode);
	}

	if (inode == sdp->sd_rindex)
		adjust_fs_space(inode);

	brelse(dibh);
	gfs2_trans_end(sdp);
	gfs2_glock_dq(&ip->i_gh);
	gfs2_holder_uninit(&ip->i_gh);
	return copied;
}

/**
 * gfs2_write_end
David Teigland's avatar
David Teigland committed
596
 * @file: The file to write to
Steven Whitehouse's avatar
Steven Whitehouse committed
597
598
599
600
601
602
603
604
605
606
 * @mapping: The address space to write to
 * @pos: The file position
 * @len: The length of the data
 * @copied:
 * @page: The page that has been written
 * @fsdata: The fsdata (unused in GFS2)
 *
 * The main write_end function for GFS2. We have a separate one for
 * stuffed files as they are slightly different, otherwise we just
 * put our locking around the VFS provided functions.
David Teigland's avatar
David Teigland committed
607
608
609
610
 *
 * Returns: errno
 */

Steven Whitehouse's avatar
Steven Whitehouse committed
611
612
613
static int gfs2_write_end(struct file *file, struct address_space *mapping,
			  loff_t pos, unsigned len, unsigned copied,
			  struct page *page, void *fsdata)
David Teigland's avatar
David Teigland committed
614
615
{
	struct inode *inode = page->mapping->host;
616
617
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
618
	struct buffer_head *dibh;
619
620
	struct gfs2_alloc *al = &ip->i_alloc;
	struct gfs2_dinode *di;
Steven Whitehouse's avatar
Steven Whitehouse committed
621
622
623
	unsigned int from = pos & (PAGE_CACHE_SIZE - 1);
	unsigned int to = from + len;
	int ret;
David Teigland's avatar
David Teigland committed
624

Steven Whitehouse's avatar
Steven Whitehouse committed
625
	BUG_ON(gfs2_glock_is_locked_by_me(ip->i_gl) == 0);
626

Steven Whitehouse's avatar
Steven Whitehouse committed
627
628
629
630
631
632
	ret = gfs2_meta_inode_buffer(ip, &dibh);
	if (unlikely(ret)) {
		unlock_page(page);
		page_cache_release(page);
		goto failed;
	}
633
634

	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
David Teigland's avatar
David Teigland committed
635

Steven Whitehouse's avatar
Steven Whitehouse committed
636
637
	if (gfs2_is_stuffed(ip))
		return gfs2_stuffed_write_end(inode, dibh, pos, len, copied, page);
David Teigland's avatar
David Teigland committed
638

Steven Whitehouse's avatar
Steven Whitehouse committed
639
640
	if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip))
		gfs2_page_add_databufs(ip, page, from, to);
David Teigland's avatar
David Teigland committed
641

Steven Whitehouse's avatar
Steven Whitehouse committed
642
	ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
David Teigland's avatar
David Teigland committed
643

Steven Whitehouse's avatar
Steven Whitehouse committed
644
645
646
647
648
649
	if (likely(ret >= 0)) {
		copied = ret;
		if  ((pos + copied) > inode->i_size) {
			di = (struct gfs2_dinode *)dibh->b_data;
			ip->i_di.di_size = inode->i_size;
			di->di_size = cpu_to_be64(inode->i_size);
650
651
			mark_inode_dirty(inode);
		}
652
653
	}

654
655
656
	if (inode == sdp->sd_rindex)
		adjust_fs_space(inode);

657
658
	brelse(dibh);
	gfs2_trans_end(sdp);
Steven Whitehouse's avatar
Steven Whitehouse committed
659
failed:
660
661
662
663
664
	if (al->al_requested) {
		gfs2_inplace_release(ip);
		gfs2_quota_unlock(ip);
		gfs2_alloc_put(ip);
	}
Steven Whitehouse's avatar
Steven Whitehouse committed
665
	gfs2_glock_dq(&ip->i_gh);
666
	gfs2_holder_uninit(&ip->i_gh);
Steven Whitehouse's avatar
Steven Whitehouse committed
667
	return ret;
David Teigland's avatar
David Teigland committed
668
669
}

670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
/**
 * 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
687
688
689
690
691
692
693
694
695
696
/**
 * 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)
{
697
	struct gfs2_inode *ip = GFS2_I(mapping->host);
David Teigland's avatar
David Teigland committed
698
699
700
701
702
703
704
705
706
	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))
707
		dblock = generic_block_bmap(mapping, lblock, gfs2_get_block);
David Teigland's avatar
David Teigland committed
708
709
710
711
712
713

	gfs2_glock_dq_uninit(&i_gh);

	return dblock;
}

714
715
716
717
718
719
720
721
722
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) {
723
724
725
726
		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);
727
728
729
730
731
732
733
734
735
	}
	bh->b_bdev = NULL;
	clear_buffer_mapped(bh);
	clear_buffer_req(bh);
	clear_buffer_new(bh);
	gfs2_log_unlock(sdp);
	unlock_buffer(bh);
}

736
static void gfs2_invalidatepage(struct page *page, unsigned long offset)
David Teigland's avatar
David Teigland committed
737
{
738
739
740
741
	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
742
	BUG_ON(!PageLocked(page));
743
744
	if (offset == 0)
		ClearPageChecked(page);
745
746
	if (!page_has_buffers(page))
		goto out;
David Teigland's avatar
David Teigland committed
747

748
749
750
751
752
753
754
755
756
757
	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
758
759
}

Steven Whitehouse's avatar
Steven Whitehouse committed
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
/**
 * 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;
}



790
791
792
static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
			      const struct iovec *iov, loff_t offset,
			      unsigned long nr_segs)
793
794
795
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
796
	struct gfs2_inode *ip = GFS2_I(inode);
797
798
799
800
	struct gfs2_holder gh;
	int rv;

	/*
Steven Whitehouse's avatar
Steven Whitehouse committed
801
802
803
804
805
806
	 * 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.
807
	 */
Steven Whitehouse's avatar
Steven Whitehouse committed
808
	gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, GL_ATIME, &gh);
809
	rv = gfs2_glock_nq_atime(&gh);
810
	if (rv)
Steven Whitehouse's avatar
Steven Whitehouse committed
811
812
813
814
815
816
817
818
		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);
819
820
821
822
823
824
out:
	gfs2_glock_dq_m(1, &gh);
	gfs2_holder_uninit(&gh);
	return rv;
}

825
/**
826
 * gfs2_releasepage - free the metadata associated with a page
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
 * @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))
844
		return 0;
845

846
	gfs2_log_lock(sdp);
847
848
	head = bh = page_buffers(page);
	do {
849
850
851
852
853
		if (atomic_read(&bh->b_count))
			goto cannot_release;
		bd = bh->b_private;
		if (bd && bd->bd_ail)
			goto cannot_release;
854
		gfs2_assert_warn(sdp, !buffer_pinned(bh));
855
		gfs2_assert_warn(sdp, !buffer_dirty(bh));
856
857
858
		bh = bh->b_this_page;
	} while(bh != head);
	gfs2_log_unlock(sdp);
859

860
861
	head = bh = page_buffers(page);
	do {
862
		gfs2_log_lock(sdp);
863
864
865
866
		bd = bh->b_private;
		if (bd) {
			gfs2_assert_warn(sdp, bd->bd_bh == bh);
			gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));
867
868
869
870
871
872
873
874
			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;
875
876
			bh->b_private = NULL;
		}
877
878
879
		gfs2_log_unlock(sdp);
		if (bd)
			kmem_cache_free(gfs2_bufdata_cachep, bd);
880
881

		bh = bh->b_this_page;
882
	} while (bh != head);
883
884

	return try_to_free_buffers(page);
885
886
887
cannot_release:
	gfs2_log_unlock(sdp);
	return 0;
888
889
}

890
const struct address_space_operations gfs2_file_aops = {
David Teigland's avatar
David Teigland committed
891
	.writepage = gfs2_writepage,
892
	.writepages = gfs2_writepages,
David Teigland's avatar
David Teigland committed
893
	.readpage = gfs2_readpage,
Steven Whitehouse's avatar
Steven Whitehouse committed
894
	.readpages = gfs2_readpages,
David Teigland's avatar
David Teigland committed
895
	.sync_page = block_sync_page,
Steven Whitehouse's avatar
Steven Whitehouse committed
896
897
	.write_begin = gfs2_write_begin,
	.write_end = gfs2_write_end,
898
	.set_page_dirty = gfs2_set_page_dirty,
David Teigland's avatar
David Teigland committed
899
900
	.bmap = gfs2_bmap,
	.invalidatepage = gfs2_invalidatepage,
901
	.releasepage = gfs2_releasepage,
David Teigland's avatar
David Teigland committed
902
903
904
	.direct_IO = gfs2_direct_IO,
};