meta_io.c 9.95 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-2006 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
16
17
18
19
 */

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/mm.h>
#include <linux/pagemap.h>
#include <linux/writeback.h>
#include <linux/swap.h>
#include <linux/delay.h>
20
#include <linux/bio.h>
21
#include <linux/gfs2_ondisk.h>
22
#include <linux/lm_interface.h>
David Teigland's avatar
David Teigland committed
23
24

#include "gfs2.h"
25
#include "incore.h"
David Teigland's avatar
David Teigland committed
26
27
28
29
30
31
32
33
#include "glock.h"
#include "glops.h"
#include "inode.h"
#include "log.h"
#include "lops.h"
#include "meta_io.h"
#include "rgrp.h"
#include "trans.h"
34
#include "util.h"
35
#include "ops_address.h"
David Teigland's avatar
David Teigland committed
36
37
38
39

static int aspace_get_block(struct inode *inode, sector_t lblock,
			    struct buffer_head *bh_result, int create)
{
40
	gfs2_assert_warn(inode->i_sb->s_fs_info, 0);
David Teigland's avatar
David Teigland committed
41
42
43
44
45
46
47
48
49
	return -EOPNOTSUPP;
}

static int gfs2_aspace_writepage(struct page *page,
				 struct writeback_control *wbc)
{
	return block_write_full_page(page, aspace_get_block, wbc);
}

50
static const struct address_space_operations aspace_aops = {
David Teigland's avatar
David Teigland committed
51
	.writepage = gfs2_aspace_writepage,
52
	.releasepage = gfs2_releasepage,
53
	.sync_page = block_sync_page,
David Teigland's avatar
David Teigland committed
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
};

/**
 * gfs2_aspace_get - Create and initialize a struct inode structure
 * @sdp: the filesystem the aspace is in
 *
 * Right now a struct inode is just a struct inode.  Maybe Linux
 * will supply a more lightweight address space construct (that works)
 * in the future.
 *
 * Make sure pages/buffers in this aspace aren't in high memory.
 *
 * Returns: the aspace
 */

struct inode *gfs2_aspace_get(struct gfs2_sbd *sdp)
{
	struct inode *aspace;

	aspace = new_inode(sdp->sd_vfs);
	if (aspace) {
75
		mapping_set_gfp_mask(aspace->i_mapping, GFP_NOFS);
David Teigland's avatar
David Teigland committed
76
77
		aspace->i_mapping->a_ops = &aspace_aops;
		aspace->i_size = ~0ULL;
78
		aspace->i_private = NULL;
David Teigland's avatar
David Teigland committed
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
		insert_inode_hash(aspace);
	}
	return aspace;
}

void gfs2_aspace_put(struct inode *aspace)
{
	remove_inode_hash(aspace);
	iput(aspace);
}

/**
 * gfs2_meta_inval - Invalidate all buffers associated with a glock
 * @gl: the glock
 *
 */

void gfs2_meta_inval(struct gfs2_glock *gl)
{
	struct gfs2_sbd *sdp = gl->gl_sbd;
	struct inode *aspace = gl->gl_aspace;
	struct address_space *mapping = gl->gl_aspace->i_mapping;

	gfs2_assert_withdraw(sdp, !atomic_read(&gl->gl_ail_count));

	atomic_inc(&aspace->i_writecount);
	truncate_inode_pages(mapping, 0);
	atomic_dec(&aspace->i_writecount);

	gfs2_assert_withdraw(sdp, !mapping->nrpages);
}

/**
 * gfs2_meta_sync - Sync all buffers associated with a glock
 * @gl: The glock
 *
 */

117
void gfs2_meta_sync(struct gfs2_glock *gl)
David Teigland's avatar
David Teigland committed
118
119
{
	struct address_space *mapping = gl->gl_aspace->i_mapping;
120
	int error;
David Teigland's avatar
David Teigland committed
121

122
123
	filemap_fdatawrite(mapping);
	error = filemap_fdatawait(mapping);
David Teigland's avatar
David Teigland committed
124
125
126
127
128
129
130

	if (error)
		gfs2_io_error(gl->gl_sbd);
}

/**
 * getbuf - Get a buffer with a given address space
131
 * @gl: the glock
David Teigland's avatar
David Teigland committed
132
133
134
135
136
137
 * @blkno: the block number (filesystem scope)
 * @create: 1 if the buffer should be created
 *
 * Returns: the buffer
 */

138
static struct buffer_head *getbuf(struct gfs2_glock *gl, u64 blkno, int create)
David Teigland's avatar
David Teigland committed
139
{
140
141
	struct address_space *mapping = gl->gl_aspace->i_mapping;
	struct gfs2_sbd *sdp = gl->gl_sbd;
David Teigland's avatar
David Teigland committed
142
143
144
145
146
147
148
149
150
151
152
153
	struct page *page;
	struct buffer_head *bh;
	unsigned int shift;
	unsigned long index;
	unsigned int bufnum;

	shift = PAGE_CACHE_SHIFT - sdp->sd_sb.sb_bsize_shift;
	index = blkno >> shift;             /* convert block to page */
	bufnum = blkno - (index << shift);  /* block buf index within page */

	if (create) {
		for (;;) {
154
			page = grab_cache_page(mapping, index);
David Teigland's avatar
David Teigland committed
155
156
157
158
159
			if (page)
				break;
			yield();
		}
	} else {
160
		page = find_lock_page(mapping, index);
David Teigland's avatar
David Teigland committed
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
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
		if (!page)
			return NULL;
	}

	if (!page_has_buffers(page))
		create_empty_buffers(page, sdp->sd_sb.sb_bsize, 0);

	/* Locate header for our buffer within our page */
	for (bh = page_buffers(page); bufnum--; bh = bh->b_this_page)
		/* Do nothing */;
	get_bh(bh);

	if (!buffer_mapped(bh))
		map_bh(bh, sdp->sd_vfs, blkno);

	unlock_page(page);
	mark_page_accessed(page);
	page_cache_release(page);

	return bh;
}

static void meta_prep_new(struct buffer_head *bh)
{
	struct gfs2_meta_header *mh = (struct gfs2_meta_header *)bh->b_data;

	lock_buffer(bh);
	clear_buffer_dirty(bh);
	set_buffer_uptodate(bh);
	unlock_buffer(bh);

	mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
}

/**
 * gfs2_meta_new - Get a block
 * @gl: The glock associated with this block
 * @blkno: The block number
 *
 * Returns: The buffer
 */

203
struct buffer_head *gfs2_meta_new(struct gfs2_glock *gl, u64 blkno)
David Teigland's avatar
David Teigland committed
204
205
{
	struct buffer_head *bh;
206
	bh = getbuf(gl, blkno, CREATE);
David Teigland's avatar
David Teigland committed
207
208
209
210
211
212
213
214
	meta_prep_new(bh);
	return bh;
}

/**
 * gfs2_meta_read - Read a block from disk
 * @gl: The glock covering the block
 * @blkno: The block number
215
 * @flags: flags
David Teigland's avatar
David Teigland committed
216
217
218
219
220
 * @bhp: the place where the buffer is returned (NULL on failure)
 *
 * Returns: errno
 */

221
int gfs2_meta_read(struct gfs2_glock *gl, u64 blkno, int flags,
David Teigland's avatar
David Teigland committed
222
223
		   struct buffer_head **bhp)
{
224
	*bhp = getbuf(gl, blkno, CREATE);
225
	if (!buffer_uptodate(*bhp)) {
226
		ll_rw_block(READ_META, 1, bhp);
227
228
229
230
231
232
		if (flags & DIO_WAIT) {
			int error = gfs2_meta_wait(gl->gl_sbd, *bhp);
			if (error) {
				brelse(*bhp);
				return error;
			}
233
234
		}
	}
David Teigland's avatar
David Teigland committed
235

236
	return 0;
David Teigland's avatar
David Teigland committed
237
238
239
}

/**
240
 * gfs2_meta_wait - Reread a block from disk
David Teigland's avatar
David Teigland committed
241
 * @sdp: the filesystem
242
 * @bh: The block to wait for
David Teigland's avatar
David Teigland committed
243
244
245
246
 *
 * Returns: errno
 */

247
int gfs2_meta_wait(struct gfs2_sbd *sdp, struct buffer_head *bh)
David Teigland's avatar
David Teigland committed
248
249
250
251
{
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
		return -EIO;

252
	wait_on_buffer(bh);
David Teigland's avatar
David Teigland committed
253

254
255
256
257
258
	if (!buffer_uptodate(bh)) {
		struct gfs2_trans *tr = current->journal_info;
		if (tr && tr->tr_touched)
			gfs2_io_error_bh(sdp, bh);
		return -EIO;
David Teigland's avatar
David Teigland committed
259
	}
260
261
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
		return -EIO;
David Teigland's avatar
David Teigland committed
262
263
264
265
266

	return 0;
}

/**
267
 * gfs2_attach_bufdata - attach a struct gfs2_bufdata structure to a buffer
David Teigland's avatar
David Teigland committed
268
269
 * @gl: the glock the buffer belongs to
 * @bh: The buffer to be attached to
270
 * @meta: Flag to indicate whether its metadata or not
David Teigland's avatar
David Teigland committed
271
272
 */

273
274
void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh,
			 int meta)
David Teigland's avatar
David Teigland committed
275
276
277
{
	struct gfs2_bufdata *bd;

278
279
	if (meta)
		lock_page(bh->b_page);
David Teigland's avatar
David Teigland committed
280

281
	if (bh->b_private) {
282
283
		if (meta)
			unlock_page(bh->b_page);
David Teigland's avatar
David Teigland committed
284
285
286
		return;
	}

287
	bd = kmem_cache_zalloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL),
David Teigland's avatar
David Teigland committed
288
289
290
291
	bd->bd_bh = bh;
	bd->bd_gl = gl;

	INIT_LIST_HEAD(&bd->bd_list_tr);
Steven Whitehouse's avatar
Steven Whitehouse committed
292
	if (meta)
293
		lops_init_le(&bd->bd_le, &gfs2_buf_lops);
Steven Whitehouse's avatar
Steven Whitehouse committed
294
	else
295
		lops_init_le(&bd->bd_le, &gfs2_databuf_lops);
296
	bh->b_private = bd;
David Teigland's avatar
David Teigland committed
297

298
299
	if (meta)
		unlock_page(bh->b_page);
David Teigland's avatar
David Teigland committed
300
301
}

302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
void gfs2_remove_from_journal(struct buffer_head *bh, struct gfs2_trans *tr, int meta)
{
	struct gfs2_sbd *sdp = GFS2_SB(bh->b_page->mapping->host);
	struct gfs2_bufdata *bd = bh->b_private;
	if (test_clear_buffer_pinned(bh)) {
		list_del_init(&bd->bd_le.le_list);
		if (meta) {
			gfs2_assert_warn(sdp, sdp->sd_log_num_buf);
			sdp->sd_log_num_buf--;
			tr->tr_num_buf_rm++;
		} else {
			gfs2_assert_warn(sdp, sdp->sd_log_num_databuf);
			sdp->sd_log_num_databuf--;
			tr->tr_num_databuf_rm++;
		}
		tr->tr_touched = 1;
		brelse(bh);
	}
	if (bd) {
		if (bd->bd_ail) {
322
			gfs2_remove_from_ail(bd);
323
324
325
326
327
328
329
330
331
332
			bh->b_private = NULL;
			bd->bd_bh = NULL;
			bd->bd_blkno = bh->b_blocknr;
			gfs2_trans_add_revoke(sdp, bd);
		}
	}
	clear_buffer_dirty(bh);
	clear_buffer_uptodate(bh);
}

David Teigland's avatar
David Teigland committed
333
334
335
336
337
338
339
340
/**
 * gfs2_meta_wipe - make inode's buffers so they aren't dirty/pinned anymore
 * @ip: the inode who owns the buffers
 * @bstart: the first buffer in the run
 * @blen: the number of buffers in the run
 *
 */

341
void gfs2_meta_wipe(struct gfs2_inode *ip, u64 bstart, u32 blen)
David Teigland's avatar
David Teigland committed
342
{
343
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teigland's avatar
David Teigland committed
344
345
346
	struct buffer_head *bh;

	while (blen) {
347
		bh = getbuf(ip->i_gl, bstart, NO_CREATE);
David Teigland's avatar
David Teigland committed
348
		if (bh) {
349
350
			lock_buffer(bh);
			gfs2_log_lock(sdp);
351
			gfs2_remove_from_journal(bh, current->journal_info, 1);
352
			gfs2_log_unlock(sdp);
David Teigland's avatar
David Teigland committed
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
			unlock_buffer(bh);
			brelse(bh);
		}

		bstart++;
		blen--;
	}
}

/**
 * gfs2_meta_indirect_buffer - Get a metadata buffer
 * @ip: The GFS2 inode
 * @height: The level of this buf in the metadata (indir addr) tree (if any)
 * @num: The block number (device relative) of the buffer
 * @new: Non-zero if we may create a new buffer
 * @bhp: the buffer is returned here
 *
 * Returns: errno
 */

373
int gfs2_meta_indirect_buffer(struct gfs2_inode *ip, int height, u64 num,
David Teigland's avatar
David Teigland committed
374
375
			      int new, struct buffer_head **bhp)
{
376
377
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	struct gfs2_glock *gl = ip->i_gl;
378
379
	struct buffer_head *bh;
	int ret = 0;
David Teigland's avatar
David Teigland committed
380
381

	if (new) {
382
383
		BUG_ON(height == 0);
		bh = gfs2_meta_new(gl, num);
384
		gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teigland's avatar
David Teigland committed
385
386
		gfs2_metatype_set(bh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);
		gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
387
388
	} else {
		u32 mtype = height ? GFS2_METATYPE_IN : GFS2_METATYPE_DI;
389
390
391
392
		ret = gfs2_meta_read(gl, num, DIO_WAIT, &bh);
		if (ret == 0 && gfs2_metatype_check(sdp, bh, mtype)) {
			brelse(bh);
			ret = -EIO;
393
		}
David Teigland's avatar
David Teigland committed
394
395
	}
	*bhp = bh;
396
	return ret;
David Teigland's avatar
David Teigland committed
397
398
399
400
401
402
403
404
}

/**
 * gfs2_meta_ra - start readahead on an extent of a file
 * @gl: the glock the blocks belong to
 * @dblock: the starting disk block
 * @extlen: the number of blocks in the extent
 *
405
 * returns: the first buffer in the extent
David Teigland's avatar
David Teigland committed
406
407
 */

408
struct buffer_head *gfs2_meta_ra(struct gfs2_glock *gl, u64 dblock, u32 extlen)
David Teigland's avatar
David Teigland committed
409
410
411
{
	struct gfs2_sbd *sdp = gl->gl_sbd;
	struct buffer_head *first_bh, *bh;
412
	u32 max_ra = gfs2_tune_get(sdp, gt_max_readahead) >>
413
			  sdp->sd_sb.sb_bsize_shift;
David Teigland's avatar
David Teigland committed
414

415
416
417
418
	BUG_ON(!extlen);

	if (max_ra < 1)
		max_ra = 1;
David Teigland's avatar
David Teigland committed
419
420
421
	if (extlen > max_ra)
		extlen = max_ra;

422
	first_bh = getbuf(gl, dblock, CREATE);
David Teigland's avatar
David Teigland committed
423
424
425

	if (buffer_uptodate(first_bh))
		goto out;
426
	if (!buffer_locked(first_bh))
427
		ll_rw_block(READ_META, 1, &first_bh);
David Teigland's avatar
David Teigland committed
428
429
430
431
432

	dblock++;
	extlen--;

	while (extlen) {
433
		bh = getbuf(gl, dblock, CREATE);
David Teigland's avatar
David Teigland committed
434

435
436
437
		if (!buffer_uptodate(bh) && !buffer_locked(bh))
			ll_rw_block(READA, 1, &bh);
		brelse(bh);
David Teigland's avatar
David Teigland committed
438
439
		dblock++;
		extlen--;
440
441
		if (!buffer_locked(first_bh) && buffer_uptodate(first_bh))
			goto out;
David Teigland's avatar
David Teigland committed
442
443
	}

444
	wait_on_buffer(first_bh);
445
out:
446
	return first_bh;
David Teigland's avatar
David Teigland committed
447
448
}