ops_address.c 22.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>
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
	if (PageChecked(page)) {
142
143
144
		error = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
		if (error)
			goto out_ignore;
145
		ClearPageChecked(page);
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
	return error;
157
158
159
160
161

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

164
165
166
167
168
169
170
171
172
173
174
175
176
/**
 * 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.
 */
177
178
static int gfs2_writepages(struct address_space *mapping,
			   struct writeback_control *wbc)
179
180
181
182
{
	struct inode *inode = mapping->host;
	struct gfs2_inode *ip = GFS2_I(inode);

183
	if (gfs2_is_writeback(ip))
184
185
186
187
188
		return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc);

	return generic_writepages(mapping, wbc);
}

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

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

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

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

	return 0;
}


/**
231
232
 * __gfs2_readpage - readpage
 * @file: The file to read a page for
David Teigland's avatar
David Teigland committed
233
234
 * @page: The page to read
 *
235
236
237
238
 * 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
239
240
 */

241
static int __gfs2_readpage(void *file, struct page *page)
David Teigland's avatar
David Teigland committed
242
{
243
244
	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
245
246
	int error;

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

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

257
258
259
260
261
262
263
264
	return error;
}

/**
 * gfs2_readpage - read a page of a file
 * @file: The file to read
 * @page: The page of the file
 *
265
 * This deals with the locking required. We use a trylock in order to
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
 * 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;

	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;
281
	}
282
283
	error = __gfs2_readpage(file, page);
	gfs2_glock_dq(&gh);
284
out:
285
	gfs2_holder_uninit(&gh);
286
287
	if (error == GLR_TRYFAILED) {
		yield();
288
		return AOP_TRUNCATED_PAGE;
289
	}
290
291
292
293
294
295
296
297
298
299
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
	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
332
333
334
335
336
337
338
339
340
341
342
}

/**
 * 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.
343
 * 2. We don't handle stuffed files here we let readpage do the honours.
Steven Whitehouse's avatar
Steven Whitehouse committed
344
345
346
 * 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.
 */
347

Steven Whitehouse's avatar
Steven Whitehouse committed
348
349
350
351
static int gfs2_readpages(struct file *file, struct address_space *mapping,
			  struct list_head *pages, unsigned nr_pages)
{
	struct inode *inode = mapping->host;
352
353
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse's avatar
Steven Whitehouse committed
354
	struct gfs2_holder gh;
355
	int ret;
Steven Whitehouse's avatar
Steven Whitehouse committed
356

357
	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
358
359
	ret = gfs2_glock_nq_atime(&gh);
	if (unlikely(ret))
360
		goto out_uninit;
361
	if (!gfs2_is_stuffed(ip))
Steven Whitehouse's avatar
Steven Whitehouse committed
362
		ret = mpage_readpages(mapping, pages, nr_pages, gfs2_get_block);
363
364
365
	gfs2_glock_dq(&gh);
out_uninit:
	gfs2_holder_uninit(&gh);
Steven Whitehouse's avatar
Steven Whitehouse committed
366
367
368
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
		ret = -EIO;
	return ret;
David Teigland's avatar
David Teigland committed
369
370
371
}

/**
Steven Whitehouse's avatar
Steven Whitehouse committed
372
 * gfs2_write_begin - Begin to write to a file
David Teigland's avatar
David Teigland committed
373
 * @file: The file to write to
Steven Whitehouse's avatar
Steven Whitehouse committed
374
375
376
377
378
379
 * @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
380
381
382
383
 *
 * Returns: errno
 */

Steven Whitehouse's avatar
Steven Whitehouse committed
384
385
386
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
387
{
Steven Whitehouse's avatar
Steven Whitehouse committed
388
389
	struct gfs2_inode *ip = GFS2_I(mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);
390
391
	unsigned int data_blocks, ind_blocks, rblocks;
	int alloc_required;
David Teigland's avatar
David Teigland committed
392
	int error = 0;
393
	struct gfs2_alloc *al;
Steven Whitehouse's avatar
Steven Whitehouse committed
394
395
396
397
	pgoff_t index = pos >> PAGE_CACHE_SHIFT;
	unsigned from = pos & (PAGE_CACHE_SIZE - 1);
	unsigned to = from + len;
	struct page *page;
398

Steven Whitehouse's avatar
Steven Whitehouse committed
399
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME, &ip->i_gh);
400
	error = gfs2_glock_nq_atime(&ip->i_gh);
Steven Whitehouse's avatar
Steven Whitehouse committed
401
	if (unlikely(error))
402
		goto out_uninit;
David Teigland's avatar
David Teigland committed
403

Steven Whitehouse's avatar
Steven Whitehouse committed
404
405
406
407
408
409
410
	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);
411

Steven Whitehouse's avatar
Steven Whitehouse committed
412
	error = gfs2_write_alloc_required(ip, pos, len, &alloc_required);
413
	if (error)
Steven Whitehouse's avatar
Steven Whitehouse committed
414
		goto out_putpage;
David Teigland's avatar
David Teigland committed
415

416

417
	ip->i_alloc.al_requested = 0;
418
419
420
421
422
423
424
	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;

425
		error = gfs2_quota_check(ip, ip->i_inode.i_uid, ip->i_inode.i_gid);
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
		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;

441
442
	error = gfs2_trans_begin(sdp, rblocks,
				 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
443
	if (error)
444
		goto out_trans_fail;
445
446

	if (gfs2_is_stuffed(ip)) {
Steven Whitehouse's avatar
Steven Whitehouse committed
447
		if (pos + len > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
448
			error = gfs2_unstuff_dinode(ip, page);
449
450
451
			if (error == 0)
				goto prepare_write;
		} else if (!PageUptodate(page))
David Teigland's avatar
David Teigland committed
452
			error = stuffed_readpage(ip, page);
453
		goto out;
454
455
	}

456
prepare_write:
457
458
459
460
461
	error = block_prepare_write(page, from, to, gfs2_get_block);

out:
	if (error) {
		gfs2_trans_end(sdp);
462
out_trans_fail:
463
464
465
466
467
468
469
		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
470
471
472
473
out_putpage:
		page_cache_release(page);
		if (pos + len > ip->i_inode.i_size)
			vmtruncate(&ip->i_inode, ip->i_inode.i_size);
474
475
476
477
478
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
479
480
481
482

	return error;
}

483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
/**
 * 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);
503
504
	fs_warn(sdp, "File system extended by %llu blocks.\n",
		(unsigned long long)new_free);
505
506
507
	gfs2_statfs_change(sdp, new_free, new_free, 0);
}

David Teigland's avatar
David Teigland committed
508
/**
Steven Whitehouse's avatar
Steven Whitehouse committed
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
 * 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
564
 * @file: The file to write to
Steven Whitehouse's avatar
Steven Whitehouse committed
565
566
567
568
569
570
571
572
573
574
 * @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
575
576
577
578
 *
 * Returns: errno
 */

Steven Whitehouse's avatar
Steven Whitehouse committed
579
580
581
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
582
583
{
	struct inode *inode = page->mapping->host;
584
585
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
586
	struct buffer_head *dibh;
587
588
	struct gfs2_alloc *al = &ip->i_alloc;
	struct gfs2_dinode *di;
Steven Whitehouse's avatar
Steven Whitehouse committed
589
590
591
	unsigned int from = pos & (PAGE_CACHE_SIZE - 1);
	unsigned int to = from + len;
	int ret;
David Teigland's avatar
David Teigland committed
592

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

Steven Whitehouse's avatar
Steven Whitehouse committed
595
596
597
598
599
600
	ret = gfs2_meta_inode_buffer(ip, &dibh);
	if (unlikely(ret)) {
		unlock_page(page);
		page_cache_release(page);
		goto failed;
	}
601
602

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

Steven Whitehouse's avatar
Steven Whitehouse committed
604
605
	if (gfs2_is_stuffed(ip))
		return gfs2_stuffed_write_end(inode, dibh, pos, len, copied, page);
David Teigland's avatar
David Teigland committed
606

607
	if (!gfs2_is_writeback(ip))
Steven Whitehouse's avatar
Steven Whitehouse committed
608
		gfs2_page_add_databufs(ip, page, from, to);
David Teigland's avatar
David Teigland committed
609

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

Steven Whitehouse's avatar
Steven Whitehouse committed
612
613
614
615
616
617
	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);
618
619
			mark_inode_dirty(inode);
		}
620
621
	}

622
623
624
	if (inode == sdp->sd_rindex)
		adjust_fs_space(inode);

625
626
	brelse(dibh);
	gfs2_trans_end(sdp);
Steven Whitehouse's avatar
Steven Whitehouse committed
627
failed:
628
629
630
631
632
	if (al->al_requested) {
		gfs2_inplace_release(ip);
		gfs2_quota_unlock(ip);
		gfs2_alloc_put(ip);
	}
Steven Whitehouse's avatar
Steven Whitehouse committed
633
	gfs2_glock_dq(&ip->i_gh);
634
	gfs2_holder_uninit(&ip->i_gh);
Steven Whitehouse's avatar
Steven Whitehouse committed
635
	return ret;
David Teigland's avatar
David Teigland committed
636
637
}

638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
/**
 * 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
655
656
657
658
659
660
661
662
663
664
/**
 * 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)
{
665
	struct gfs2_inode *ip = GFS2_I(mapping->host);
David Teigland's avatar
David Teigland committed
666
667
668
669
670
671
672
673
674
	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))
675
		dblock = generic_block_bmap(mapping, lblock, gfs2_get_block);
David Teigland's avatar
David Teigland committed
676
677
678
679
680
681

	gfs2_glock_dq_uninit(&i_gh);

	return dblock;
}

682
683
684
685
686
687
688
689
690
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) {
691
692
693
694
		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);
695
696
697
698
699
700
701
702
703
	}
	bh->b_bdev = NULL;
	clear_buffer_mapped(bh);
	clear_buffer_req(bh);
	clear_buffer_new(bh);
	gfs2_log_unlock(sdp);
	unlock_buffer(bh);
}

704
static void gfs2_invalidatepage(struct page *page, unsigned long offset)
David Teigland's avatar
David Teigland committed
705
{
706
707
708
709
	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
710
	BUG_ON(!PageLocked(page));
711
712
	if (offset == 0)
		ClearPageChecked(page);
713
714
	if (!page_has_buffers(page))
		goto out;
David Teigland's avatar
David Teigland committed
715

716
717
718
719
720
721
722
723
724
725
	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
726
727
}

Steven Whitehouse's avatar
Steven Whitehouse committed
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
/**
 * 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;
}



758
759
760
static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
			      const struct iovec *iov, loff_t offset,
			      unsigned long nr_segs)
761
762
763
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
764
	struct gfs2_inode *ip = GFS2_I(inode);
765
766
767
768
	struct gfs2_holder gh;
	int rv;

	/*
Steven Whitehouse's avatar
Steven Whitehouse committed
769
770
771
772
773
774
	 * 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.
775
	 */
Steven Whitehouse's avatar
Steven Whitehouse committed
776
	gfs2_holder_init(ip->i_gl, LM_ST_DEFERRED, GL_ATIME, &gh);
777
	rv = gfs2_glock_nq_atime(&gh);
778
	if (rv)
Steven Whitehouse's avatar
Steven Whitehouse committed
779
780
781
782
783
784
785
786
		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);
787
788
789
790
791
792
out:
	gfs2_glock_dq_m(1, &gh);
	gfs2_holder_uninit(&gh);
	return rv;
}

793
/**
794
 * gfs2_releasepage - free the metadata associated with a page
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
 * @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))
812
		return 0;
813

814
	gfs2_log_lock(sdp);
815
816
	head = bh = page_buffers(page);
	do {
817
818
819
820
821
		if (atomic_read(&bh->b_count))
			goto cannot_release;
		bd = bh->b_private;
		if (bd && bd->bd_ail)
			goto cannot_release;
822
		gfs2_assert_warn(sdp, !buffer_pinned(bh));
823
		gfs2_assert_warn(sdp, !buffer_dirty(bh));
824
825
826
		bh = bh->b_this_page;
	} while(bh != head);
	gfs2_log_unlock(sdp);
827

828
829
	head = bh = page_buffers(page);
	do {
830
		gfs2_log_lock(sdp);
831
832
833
834
		bd = bh->b_private;
		if (bd) {
			gfs2_assert_warn(sdp, bd->bd_bh == bh);
			gfs2_assert_warn(sdp, list_empty(&bd->bd_list_tr));
835
836
837
838
839
840
841
842
			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;
843
844
			bh->b_private = NULL;
		}
845
846
847
		gfs2_log_unlock(sdp);
		if (bd)
			kmem_cache_free(gfs2_bufdata_cachep, bd);
848
849

		bh = bh->b_this_page;
850
	} while (bh != head);
851
852

	return try_to_free_buffers(page);
853
854
855
cannot_release:
	gfs2_log_unlock(sdp);
	return 0;
856
857
}

858
const struct address_space_operations gfs2_file_aops = {
David Teigland's avatar
David Teigland committed
859
	.writepage = gfs2_writepage,
860
	.writepages = gfs2_writepages,
David Teigland's avatar
David Teigland committed
861
	.readpage = gfs2_readpage,
Steven Whitehouse's avatar
Steven Whitehouse committed
862
	.readpages = gfs2_readpages,
David Teigland's avatar
David Teigland committed
863
	.sync_page = block_sync_page,
Steven Whitehouse's avatar
Steven Whitehouse committed
864
865
	.write_begin = gfs2_write_begin,
	.write_end = gfs2_write_end,
866
	.set_page_dirty = gfs2_set_page_dirty,
David Teigland's avatar
David Teigland committed
867
868
	.bmap = gfs2_bmap,
	.invalidatepage = gfs2_invalidatepage,
869
	.releasepage = gfs2_releasepage,
David Teigland's avatar
David Teigland committed
870
871
872
	.direct_IO = gfs2_direct_IO,
};