ops_address.c 28.8 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/backing-dev.h>
24
#include <linux/pagevec.h>
David Teigland's avatar
David Teigland committed
25
26

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

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

static void gfs2_page_add_databufs(struct gfs2_inode *ip, struct page *page,
				   unsigned int from, unsigned int to)
{
	struct buffer_head *head = page_buffers(page);
	unsigned int bsize = head->b_size;
	struct buffer_head *bh;
	unsigned int start, end;

	for (bh = head, start = 0; bh != head || !start;
	     bh = bh->b_this_page, start = end) {
		end = start + bsize;
		if (end <= from || start >= to)
			continue;
Benjamin Marzinski's avatar
Benjamin Marzinski committed
55
56
		if (gfs2_is_jdata(ip))
			set_buffer_uptodate(bh);
Steven Whitehouse's avatar
Steven Whitehouse committed
57
58
59
60
		gfs2_trans_add_bh(ip->i_gl, bh, 0);
	}
}

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

71
72
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
73
74
75
{
	int error;

76
	error = gfs2_block_map(inode, lblock, bh_result, 0);
David Teigland's avatar
David Teigland committed
77
78
	if (error)
		return error;
Wendy Cheng's avatar
Wendy Cheng committed
79
	if (!buffer_mapped(bh_result))
80
81
		return -EIO;
	return 0;
David Teigland's avatar
David Teigland committed
82
83
}

84
85
static int gfs2_get_block_direct(struct inode *inode, sector_t lblock,
				 struct buffer_head *bh_result, int create)
86
{
87
	return gfs2_block_map(inode, lblock, bh_result, 0);
88
}
89

David Teigland's avatar
David Teigland committed
90
/**
91
92
93
 * gfs2_writepage_common - Common bits of writepage
 * @page: The page to be written
 * @wbc: The writeback control
David Teigland's avatar
David Teigland committed
94
 *
95
 * Returns: 1 if writepage is ok, otherwise an error code or zero if no error.
David Teigland's avatar
David Teigland committed
96
97
 */

98
99
static int gfs2_writepage_common(struct page *page,
				 struct writeback_control *wbc)
David Teigland's avatar
David Teigland committed
100
{
101
	struct inode *inode = page->mapping->host;
102
103
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
104
105
106
	loff_t i_size = i_size_read(inode);
	pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
	unsigned offset;
107
	int ret = -EIO;
David Teigland's avatar
David Teigland committed
108

109
110
111
	if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl)))
		goto out;
	ret = 0;
112
	if (current->journal_info)
113
		goto redirty;
114
	/* Is the page fully outside i_size? (truncate in progress) */
115
	offset = i_size & (PAGE_CACHE_SIZE-1);
116
	if (page->index > end_index || (page->index == end_index && !offset)) {
117
		page->mapping->a_ops->invalidatepage(page, 0);
118
		goto out;
David Teigland's avatar
David Teigland committed
119
	}
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
	return 1;
redirty:
	redirty_page_for_writepage(wbc, page);
out:
	unlock_page(page);
	return 0;
}

/**
 * gfs2_writeback_writepage - Write page for writeback mappings
 * @page: The page
 * @wbc: The writeback control
 *
 */

static int gfs2_writeback_writepage(struct page *page,
				    struct writeback_control *wbc)
{
	int ret;

	ret = gfs2_writepage_common(page, wbc);
	if (ret <= 0)
		return ret;

	ret = mpage_writepage(page, gfs2_get_block_noalloc, wbc);
	if (ret == -EAGAIN)
		ret = block_write_full_page(page, gfs2_get_block_noalloc, wbc);
	return ret;
}

/**
 * gfs2_ordered_writepage - Write page for ordered data files
 * @page: The page to write
 * @wbc: The writeback control
 *
 */

static int gfs2_ordered_writepage(struct page *page,
				  struct writeback_control *wbc)
{
	struct inode *inode = page->mapping->host;
	struct gfs2_inode *ip = GFS2_I(inode);
	int ret;

	ret = gfs2_writepage_common(page, wbc);
	if (ret <= 0)
		return ret;

	if (!page_has_buffers(page)) {
		create_empty_buffers(page, inode->i_sb->s_blocksize,
				     (1 << BH_Dirty)|(1 << BH_Uptodate));
	}
	gfs2_page_add_databufs(ip, page, 0, inode->i_sb->s_blocksize-1);
	return block_write_full_page(page, gfs2_get_block_noalloc, wbc);
}

176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
/**
 * __gfs2_jdata_writepage - The core of jdata writepage
 * @page: The page to write
 * @wbc: The writeback control
 *
 * This is shared between writepage and writepages and implements the
 * core of the writepage operation. If a transaction is required then
 * PageChecked will have been set and the transaction will have
 * already been started before this is called.
 */

static int __gfs2_jdata_writepage(struct page *page, struct writeback_control *wbc)
{
	struct inode *inode = page->mapping->host;
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);

	if (PageChecked(page)) {
		ClearPageChecked(page);
		if (!page_has_buffers(page)) {
			create_empty_buffers(page, inode->i_sb->s_blocksize,
					     (1 << BH_Dirty)|(1 << BH_Uptodate));
		}
		gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
	}
	return block_write_full_page(page, gfs2_get_block_noalloc, wbc);
}

204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
/**
 * gfs2_jdata_writepage - Write complete page
 * @page: Page to write
 *
 * Returns: errno
 *
 */

static int gfs2_jdata_writepage(struct page *page, struct writeback_control *wbc)
{
	struct inode *inode = page->mapping->host;
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	int error;
	int done_trans = 0;

	error = gfs2_writepage_common(page, wbc);
	if (error <= 0)
		return error;
David Teigland's avatar
David Teigland committed
222

223
	if (PageChecked(page)) {
224
225
		if (wbc->sync_mode != WB_SYNC_ALL)
			goto out_ignore;
226
227
228
229
230
		error = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
		if (error)
			goto out_ignore;
		done_trans = 1;
	}
231
	error = __gfs2_jdata_writepage(page, wbc);
232
233
	if (done_trans)
		gfs2_trans_end(sdp);
David Teigland's avatar
David Teigland committed
234
	return error;
235
236
237
238
239

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

242
/**
243
 * gfs2_writeback_writepages - Write a bunch of dirty pages back to disk
244
245
246
 * @mapping: The mapping to write
 * @wbc: Write-back control
 *
247
 * For the data=writeback case we can already ignore buffer heads
248
249
250
 * 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.
 */
251
252
static int gfs2_writeback_writepages(struct address_space *mapping,
				     struct writeback_control *wbc)
253
{
254
	return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc);
255
256
}

257
258
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
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
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
/**
 * gfs2_write_jdata_pagevec - Write back a pagevec's worth of pages
 * @mapping: The mapping
 * @wbc: The writeback control
 * @writepage: The writepage function to call for each page
 * @pvec: The vector of pages
 * @nr_pages: The number of pages to write
 *
 * Returns: non-zero if loop should terminate, zero otherwise
 */

static int gfs2_write_jdata_pagevec(struct address_space *mapping,
				    struct writeback_control *wbc,
				    struct pagevec *pvec,
				    int nr_pages, pgoff_t end)
{
	struct inode *inode = mapping->host;
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	loff_t i_size = i_size_read(inode);
	pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
	unsigned offset = i_size & (PAGE_CACHE_SIZE-1);
	unsigned nrblocks = nr_pages * (PAGE_CACHE_SIZE/inode->i_sb->s_blocksize);
	struct backing_dev_info *bdi = mapping->backing_dev_info;
	int i;
	int ret;

	ret = gfs2_trans_begin(sdp, nrblocks, 0);
	if (ret < 0)
		return ret;

	for(i = 0; i < nr_pages; i++) {
		struct page *page = pvec->pages[i];

		lock_page(page);

		if (unlikely(page->mapping != mapping)) {
			unlock_page(page);
			continue;
		}

		if (!wbc->range_cyclic && page->index > end) {
			ret = 1;
			unlock_page(page);
			continue;
		}

		if (wbc->sync_mode != WB_SYNC_NONE)
			wait_on_page_writeback(page);

		if (PageWriteback(page) ||
		    !clear_page_dirty_for_io(page)) {
			unlock_page(page);
			continue;
		}

		/* Is the page fully outside i_size? (truncate in progress) */
		if (page->index > end_index || (page->index == end_index && !offset)) {
			page->mapping->a_ops->invalidatepage(page, 0);
			unlock_page(page);
			continue;
		}

		ret = __gfs2_jdata_writepage(page, wbc);

		if (ret || (--(wbc->nr_to_write) <= 0))
			ret = 1;
		if (wbc->nonblocking && bdi_write_congested(bdi)) {
			wbc->encountered_congestion = 1;
			ret = 1;
		}

	}
	gfs2_trans_end(sdp);
	return ret;
}

/**
 * gfs2_write_cache_jdata - Like write_cache_pages but different
 * @mapping: The mapping to write
 * @wbc: The writeback control
 * @writepage: The writepage function to call
 * @data: The data to pass to writepage
 *
 * The reason that we use our own function here is that we need to
 * start transactions before we grab page locks. This allows us
 * to get the ordering right.
 */

static int gfs2_write_cache_jdata(struct address_space *mapping,
				  struct writeback_control *wbc)
{
	struct backing_dev_info *bdi = mapping->backing_dev_info;
	int ret = 0;
	int done = 0;
	struct pagevec pvec;
	int nr_pages;
	pgoff_t index;
	pgoff_t end;
	int scanned = 0;
	int range_whole = 0;

	if (wbc->nonblocking && bdi_write_congested(bdi)) {
		wbc->encountered_congestion = 1;
		return 0;
	}

	pagevec_init(&pvec, 0);
	if (wbc->range_cyclic) {
		index = mapping->writeback_index; /* Start from prev offset */
		end = -1;
	} else {
		index = wbc->range_start >> PAGE_CACHE_SHIFT;
		end = wbc->range_end >> PAGE_CACHE_SHIFT;
		if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
			range_whole = 1;
		scanned = 1;
	}

retry:
	 while (!done && (index <= end) &&
		(nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
					       PAGECACHE_TAG_DIRTY,
					       min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1))) {
		scanned = 1;
		ret = gfs2_write_jdata_pagevec(mapping, wbc, &pvec, nr_pages, end);
		if (ret)
			done = 1;
		if (ret > 0)
			ret = 0;

		pagevec_release(&pvec);
		cond_resched();
	}

	if (!scanned && !done) {
		/*
		 * We hit the last page and there is more work to be done: wrap
		 * back to the start of the file
		 */
		scanned = 1;
		index = 0;
		goto retry;
	}

	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
		mapping->writeback_index = index;
	return ret;
}


/**
 * gfs2_jdata_writepages - Write a bunch of dirty pages back to disk
 * @mapping: The mapping to write
 * @wbc: The writeback control
 * 
 */

static int gfs2_jdata_writepages(struct address_space *mapping,
				 struct writeback_control *wbc)
{
	struct gfs2_inode *ip = GFS2_I(mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);
	int ret;

	ret = gfs2_write_cache_jdata(mapping, wbc);
	if (ret == 0 && wbc->sync_mode == WB_SYNC_ALL) {
		gfs2_log_flush(sdp, ip->i_gl);
		ret = gfs2_write_cache_jdata(mapping, wbc);
	}
	return ret;
}

David Teigland's avatar
David Teigland committed
429
430
431
432
433
434
435
436
437
438
439
440
441
442
/**
 * 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;

443
444
445
446
447
448
	/*
	 * 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)) {
449
		zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
450
451
		return 0;
	}
Steven Whitehouse's avatar
Steven Whitehouse committed
452

David Teigland's avatar
David Teigland committed
453
454
455
456
	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		return error;

457
	kaddr = kmap_atomic(page, KM_USER0);
Steven Whitehouse's avatar
Steven Whitehouse committed
458
	memcpy(kaddr, dibh->b_data + sizeof(struct gfs2_dinode),
David Teigland's avatar
David Teigland committed
459
	       ip->i_di.di_size);
Steven Whitehouse's avatar
Steven Whitehouse committed
460
	memset(kaddr + ip->i_di.di_size, 0, PAGE_CACHE_SIZE - ip->i_di.di_size);
461
	kunmap_atomic(kaddr, KM_USER0);
462
	flush_dcache_page(page);
David Teigland's avatar
David Teigland committed
463
464
465
466
467
468
469
470
	brelse(dibh);
	SetPageUptodate(page);

	return 0;
}


/**
471
472
 * __gfs2_readpage - readpage
 * @file: The file to read a page for
David Teigland's avatar
David Teigland committed
473
474
 * @page: The page to read
 *
475
476
477
478
 * 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
479
480
 */

481
static int __gfs2_readpage(void *file, struct page *page)
David Teigland's avatar
David Teigland committed
482
{
483
484
	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
485
486
	int error;

487
	if (gfs2_is_stuffed(ip)) {
Steven Whitehouse's avatar
Steven Whitehouse committed
488
489
		error = stuffed_readpage(ip, page);
		unlock_page(page);
490
	} else {
491
		error = mpage_readpage(page, gfs2_block_map);
492
	}
David Teigland's avatar
David Teigland committed
493
494

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

497
498
499
500
501
502
503
504
	return error;
}

/**
 * gfs2_readpage - read a page of a file
 * @file: The file to read
 * @page: The page of the file
 *
505
 * This deals with the locking required. We use a trylock in order to
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
 * 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;
521
	}
522
523
	error = __gfs2_readpage(file, page);
	gfs2_glock_dq(&gh);
524
out:
525
	gfs2_holder_uninit(&gh);
526
527
	if (error == GLR_TRYFAILED) {
		yield();
528
		return AOP_TRUNCATED_PAGE;
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
564
565
566
567
568
569
570
571
	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
572
573
574
575
576
577
578
579
580
581
582
}

/**
 * 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.
583
 * 2. We don't handle stuffed files here we let readpage do the honours.
Steven Whitehouse's avatar
Steven Whitehouse committed
584
 * 3. mpage_readpages() does most of the heavy lifting in the common case.
585
 * 4. gfs2_block_map() is relied upon to set BH_Boundary in the right places.
Steven Whitehouse's avatar
Steven Whitehouse committed
586
 */
587

Steven Whitehouse's avatar
Steven Whitehouse committed
588
589
590
591
static int gfs2_readpages(struct file *file, struct address_space *mapping,
			  struct list_head *pages, unsigned nr_pages)
{
	struct inode *inode = mapping->host;
592
593
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse's avatar
Steven Whitehouse committed
594
	struct gfs2_holder gh;
595
	int ret;
Steven Whitehouse's avatar
Steven Whitehouse committed
596

597
	gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
598
599
	ret = gfs2_glock_nq_atime(&gh);
	if (unlikely(ret))
600
		goto out_uninit;
601
	if (!gfs2_is_stuffed(ip))
602
		ret = mpage_readpages(mapping, pages, nr_pages, gfs2_block_map);
603
604
605
	gfs2_glock_dq(&gh);
out_uninit:
	gfs2_holder_uninit(&gh);
Steven Whitehouse's avatar
Steven Whitehouse committed
606
607
608
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
		ret = -EIO;
	return ret;
David Teigland's avatar
David Teigland committed
609
610
611
}

/**
Steven Whitehouse's avatar
Steven Whitehouse committed
612
 * gfs2_write_begin - Begin to write to a file
David Teigland's avatar
David Teigland committed
613
 * @file: The file to write to
Steven Whitehouse's avatar
Steven Whitehouse committed
614
615
616
617
618
619
 * @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
620
621
622
623
 *
 * Returns: errno
 */

Steven Whitehouse's avatar
Steven Whitehouse committed
624
625
626
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
627
{
Steven Whitehouse's avatar
Steven Whitehouse committed
628
629
	struct gfs2_inode *ip = GFS2_I(mapping->host);
	struct gfs2_sbd *sdp = GFS2_SB(mapping->host);
630
631
	unsigned int data_blocks, ind_blocks, rblocks;
	int alloc_required;
David Teigland's avatar
David Teigland committed
632
	int error = 0;
633
	struct gfs2_alloc *al;
Steven Whitehouse's avatar
Steven Whitehouse committed
634
635
636
637
	pgoff_t index = pos >> PAGE_CACHE_SHIFT;
	unsigned from = pos & (PAGE_CACHE_SIZE - 1);
	unsigned to = from + len;
	struct page *page;
638

Steven Whitehouse's avatar
Steven Whitehouse committed
639
	gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME, &ip->i_gh);
640
	error = gfs2_glock_nq_atime(&ip->i_gh);
Steven Whitehouse's avatar
Steven Whitehouse committed
641
	if (unlikely(error))
642
		goto out_uninit;
David Teigland's avatar
David Teigland committed
643

Steven Whitehouse's avatar
Steven Whitehouse committed
644
645
	gfs2_write_calc_reserv(ip, len, &data_blocks, &ind_blocks);
	error = gfs2_write_alloc_required(ip, pos, len, &alloc_required);
646
	if (error)
647
		goto out_unlock;
648

649
	ip->i_alloc.al_requested = 0;
650
651
652
653
654
655
656
	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;

657
		error = gfs2_quota_check(ip, ip->i_inode.i_uid, ip->i_inode.i_gid);
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
		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;

673
674
	error = gfs2_trans_begin(sdp, rblocks,
				 PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize);
675
	if (error)
676
		goto out_trans_fail;
677

678
679
680
681
682
683
	error = -ENOMEM;
	page = __grab_cache_page(mapping, index);
	*pagep = page;
	if (unlikely(!page))
		goto out_endtrans;

684
	if (gfs2_is_stuffed(ip)) {
685
		error = 0;
Steven Whitehouse's avatar
Steven Whitehouse committed
686
		if (pos + len > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
687
			error = gfs2_unstuff_dinode(ip, page);
688
689
			if (error == 0)
				goto prepare_write;
690
		} else if (!PageUptodate(page)) {
David Teigland's avatar
David Teigland committed
691
			error = stuffed_readpage(ip, page);
692
		}
693
		goto out;
694
695
	}

696
prepare_write:
697
	error = block_prepare_write(page, from, to, gfs2_block_map);
698
out:
699
700
701
702
703
704
705
706
	if (error == 0)
		return 0;

	page_cache_release(page);
	if (pos + len > ip->i_inode.i_size)
		vmtruncate(&ip->i_inode, ip->i_inode.i_size);
out_endtrans:
	gfs2_trans_end(sdp);
707
out_trans_fail:
708
709
	if (alloc_required) {
		gfs2_inplace_release(ip);
710
out_qunlock:
711
		gfs2_quota_unlock(ip);
712
out_alloc_put:
713
714
		gfs2_alloc_put(ip);
	}
715
out_unlock:
716
	gfs2_glock_dq(&ip->i_gh);
717
out_uninit:
718
	gfs2_holder_uninit(&ip->i_gh);
David Teigland's avatar
David Teigland committed
719
720
721
	return error;
}

722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
/**
 * 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);
742
743
	fs_warn(sdp, "File system extended by %llu blocks.\n",
		(unsigned long long)new_free);
744
745
746
	gfs2_statfs_change(sdp, new_free, new_free, 0);
}

David Teigland's avatar
David Teigland committed
747
/**
Steven Whitehouse's avatar
Steven Whitehouse committed
748
749
750
751
752
753
754
755
756
757
758
759
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
790
791
792
793
794
795
796
797
798
799
800
801
802
 * 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
803
 * @file: The file to write to
Steven Whitehouse's avatar
Steven Whitehouse committed
804
805
806
807
808
809
810
811
812
813
 * @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
814
815
816
817
 *
 * Returns: errno
 */

Steven Whitehouse's avatar
Steven Whitehouse committed
818
819
820
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
821
822
{
	struct inode *inode = page->mapping->host;
823
824
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
825
	struct buffer_head *dibh;
826
827
	struct gfs2_alloc *al = &ip->i_alloc;
	struct gfs2_dinode *di;
Steven Whitehouse's avatar
Steven Whitehouse committed
828
829
830
	unsigned int from = pos & (PAGE_CACHE_SIZE - 1);
	unsigned int to = from + len;
	int ret;
David Teigland's avatar
David Teigland committed
831

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

Steven Whitehouse's avatar
Steven Whitehouse committed
834
835
836
837
838
839
	ret = gfs2_meta_inode_buffer(ip, &dibh);
	if (unlikely(ret)) {
		unlock_page(page);
		page_cache_release(page);
		goto failed;
	}
840
841

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

Steven Whitehouse's avatar
Steven Whitehouse committed
843
844
	if (gfs2_is_stuffed(ip))
		return gfs2_stuffed_write_end(inode, dibh, pos, len, copied, page);
David Teigland's avatar
David Teigland committed
845

846
	if (!gfs2_is_writeback(ip))
Steven Whitehouse's avatar
Steven Whitehouse committed
847
		gfs2_page_add_databufs(ip, page, from, to);
David Teigland's avatar
David Teigland committed
848

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

Steven Whitehouse's avatar
Steven Whitehouse committed
851
852
853
854
855
856
	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);
857
858
			mark_inode_dirty(inode);
		}
859
860
	}

861
862
863
	if (inode == sdp->sd_rindex)
		adjust_fs_space(inode);

864
865
	brelse(dibh);
	gfs2_trans_end(sdp);
Steven Whitehouse's avatar
Steven Whitehouse committed
866
failed:
867
868
869
870
871
	if (al->al_requested) {
		gfs2_inplace_release(ip);
		gfs2_quota_unlock(ip);
		gfs2_alloc_put(ip);
	}
Steven Whitehouse's avatar
Steven Whitehouse committed
872
	gfs2_glock_dq(&ip->i_gh);
873
	gfs2_holder_uninit(&ip->i_gh);
Steven Whitehouse's avatar
Steven Whitehouse committed
874
	return ret;
David Teigland's avatar
David Teigland committed
875
876
}

877
878
879
880
881
882
883
884
885
/**
 * 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)
{
886
	SetPageChecked(page);
887
888
889
	return __set_page_dirty_buffers(page);
}

David Teigland's avatar
David Teigland committed
890
891
892
893
894
895
896
897
898
899
/**
 * 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)
{
900
	struct gfs2_inode *ip = GFS2_I(mapping->host);
David Teigland's avatar
David Teigland committed
901
902
903
904
905
906
907
908
909
	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))
910
		dblock = generic_block_bmap(mapping, lblock, gfs2_block_map);
David Teigland's avatar
David Teigland committed
911
912
913
914
915
916

	gfs2_glock_dq_uninit(&i_gh);

	return dblock;
}

917
918
919
920
921
922
923
924
925
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) {
926
927
928
929
		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);
930
931
932
933
934
935
936
937
938
	}
	bh->b_bdev = NULL;
	clear_buffer_mapped(bh);
	clear_buffer_req(bh);
	clear_buffer_new(bh);
	gfs2_log_unlock(sdp);
	unlock_buffer(bh);
}

939
static void gfs2_invalidatepage(struct page *page, unsigned long offset)
David Teigland's avatar
David Teigland committed
940
{
941
942
943
944
	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
945
	BUG_ON(!PageLocked(page));
946
947
	if (offset == 0)
		ClearPageChecked(page);
948
949
	if (!page_has_buffers(page))
		goto out;
David Teigland's avatar
David Teigland committed
950

951
952
953
954
955
956
957
958
959
960
	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
961
962
}

Steven Whitehouse's avatar
Steven Whitehouse committed
963
964
965
966
967
968
969
970
971
972
973
974
975
/**
 * 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
976
977
	 * a stuffed file makes any sense. For now we'll silently fall
	 * back to buffered I/O
Steven Whitehouse's avatar
Steven Whitehouse committed
978
979
980
981
982
983
984
985
986
987
988
	 */
	if (gfs2_is_stuffed(ip))
		return 0;

	if (offset > i_size_read(&ip->i_inode))
		return 0;
	return 1;
}



989
990
991
static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
			      const struct iovec *iov, loff_t offset,
			      unsigned long nr_segs)
992
993
994
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
995
	struct gfs2_inode *ip = GFS2_I(inode);
996
997
998
999
	struct gfs2_holder gh;
	int rv;

	/*
Steven Whitehouse's avatar
Steven Whitehouse committed
1000
	 * Deferred lock, even if its a write, since we do no allocation
For faster browsing, not all history is shown. View entire blame