meta_io.c 9.9 KB
Newer Older
D
David Teigland 已提交
1 2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3
 * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
D
David Teigland 已提交
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.
D
David Teigland 已提交
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>
D
David Teigland 已提交
22 23

#include "gfs2.h"
24
#include "incore.h"
D
David Teigland 已提交
25 26 27 28 29 30 31 32
#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"
33
#include "util.h"
34
#include "trace_gfs2.h"
D
David Teigland 已提交
35

36
static int gfs2_aspace_writepage(struct page *page, struct writeback_control *wbc)
D
David Teigland 已提交
37
{
38 39
	struct buffer_head *bh, *head;
	int nr_underway = 0;
40
	int write_op = REQ_META | REQ_PRIO |
J
Jens Axboe 已提交
41
		(wbc->sync_mode == WB_SYNC_ALL ? WRITE_SYNC : WRITE);
D
David Teigland 已提交
42

43 44 45 46 47 48 49 50 51 52 53 54
	BUG_ON(!PageLocked(page));
	BUG_ON(!page_has_buffers(page));

	head = page_buffers(page);
	bh = head;

	do {
		if (!buffer_mapped(bh))
			continue;
		/*
		 * If it's a fully non-blocking write attempt and we cannot
		 * lock the buffer then redirty the page.  Note that this can
55
		 * potentially cause a busy-wait loop from flusher thread and kswapd
56 57 58
		 * activity, but those code paths have their own higher-level
		 * throttling.
		 */
59
		if (wbc->sync_mode != WB_SYNC_NONE) {
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
			lock_buffer(bh);
		} else if (!trylock_buffer(bh)) {
			redirty_page_for_writepage(wbc, page);
			continue;
		}
		if (test_clear_buffer_dirty(bh)) {
			mark_buffer_async_write(bh);
		} else {
			unlock_buffer(bh);
		}
	} while ((bh = bh->b_this_page) != head);

	/*
	 * The page and its buffers are protected by PageWriteback(), so we can
	 * drop the bh refcounts early.
	 */
	BUG_ON(PageWriteback(page));
	set_page_writeback(page);

	do {
		struct buffer_head *next = bh->b_this_page;
		if (buffer_async_write(bh)) {
			submit_bh(write_op, bh);
			nr_underway++;
		}
		bh = next;
	} while (bh != head);
	unlock_page(page);

	if (nr_underway == 0)
		end_page_writeback(page);

92
	return 0;
D
David Teigland 已提交
93 94
}

95
const struct address_space_operations gfs2_meta_aops = {
D
David Teigland 已提交
96
	.writepage = gfs2_aspace_writepage,
S
Steven Whitehouse 已提交
97
	.releasepage = gfs2_releasepage,
D
David Teigland 已提交
98 99 100 101 102 103 104 105
};

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

S
Steven Whitehouse 已提交
106
void gfs2_meta_sync(struct gfs2_glock *gl)
D
David Teigland 已提交
107
{
108
	struct address_space *mapping = gfs2_glock2aspace(gl);
S
Steven Whitehouse 已提交
109
	int error;
D
David Teigland 已提交
110

S
Steven Whitehouse 已提交
111 112
	filemap_fdatawrite(mapping);
	error = filemap_fdatawait(mapping);
D
David Teigland 已提交
113 114 115 116 117 118

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

/**
119
 * gfs2_getbuf - Get a buffer with a given address space
120
 * @gl: the glock
D
David Teigland 已提交
121 122 123 124 125 126
 * @blkno: the block number (filesystem scope)
 * @create: 1 if the buffer should be created
 *
 * Returns: the buffer
 */

127
struct buffer_head *gfs2_getbuf(struct gfs2_glock *gl, u64 blkno, int create)
D
David Teigland 已提交
128
{
129
	struct address_space *mapping = gfs2_glock2aspace(gl);
130
	struct gfs2_sbd *sdp = gl->gl_sbd;
D
David Teigland 已提交
131 132 133 134 135 136 137 138 139 140 141 142
	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 (;;) {
143
			page = grab_cache_page(mapping, index);
D
David Teigland 已提交
144 145 146 147 148
			if (page)
				break;
			yield();
		}
	} else {
149
		page = find_lock_page(mapping, index);
D
David Teigland 已提交
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 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
		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
 */

192
struct buffer_head *gfs2_meta_new(struct gfs2_glock *gl, u64 blkno)
D
David Teigland 已提交
193 194
{
	struct buffer_head *bh;
195
	bh = gfs2_getbuf(gl, blkno, CREATE);
D
David Teigland 已提交
196 197 198 199 200 201 202 203
	meta_prep_new(bh);
	return bh;
}

/**
 * gfs2_meta_read - Read a block from disk
 * @gl: The glock covering the block
 * @blkno: The block number
S
Steven Whitehouse 已提交
204
 * @flags: flags
D
David Teigland 已提交
205 206 207 208 209
 * @bhp: the place where the buffer is returned (NULL on failure)
 *
 * Returns: errno
 */

210
int gfs2_meta_read(struct gfs2_glock *gl, u64 blkno, int flags,
D
David Teigland 已提交
211 212
		   struct buffer_head **bhp)
{
S
Steven Whitehouse 已提交
213 214 215
	struct gfs2_sbd *sdp = gl->gl_sbd;
	struct buffer_head *bh;

216 217
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) {
		*bhp = NULL;
S
Steven Whitehouse 已提交
218
		return -EIO;
219
	}
S
Steven Whitehouse 已提交
220 221 222 223 224 225 226 227 228 229

	*bhp = bh = gfs2_getbuf(gl, blkno, CREATE);

	lock_buffer(bh);
	if (buffer_uptodate(bh)) {
		unlock_buffer(bh);
		return 0;
	}
	bh->b_end_io = end_buffer_read_sync;
	get_bh(bh);
230
	submit_bh(READ_SYNC | REQ_META | REQ_PRIO, bh);
S
Steven Whitehouse 已提交
231 232 233 234 235 236 237 238 239
	if (!(flags & DIO_WAIT))
		return 0;

	wait_on_buffer(bh);
	if (unlikely(!buffer_uptodate(bh))) {
		struct gfs2_trans *tr = current->journal_info;
		if (tr && tr->tr_touched)
			gfs2_io_error_bh(sdp, bh);
		brelse(bh);
240
		*bhp = NULL;
S
Steven Whitehouse 已提交
241
		return -EIO;
S
Steven Whitehouse 已提交
242
	}
D
David Teigland 已提交
243

S
Steven Whitehouse 已提交
244
	return 0;
D
David Teigland 已提交
245 246 247
}

/**
S
Steven Whitehouse 已提交
248
 * gfs2_meta_wait - Reread a block from disk
D
David Teigland 已提交
249
 * @sdp: the filesystem
S
Steven Whitehouse 已提交
250
 * @bh: The block to wait for
D
David Teigland 已提交
251 252 253 254
 *
 * Returns: errno
 */

S
Steven Whitehouse 已提交
255
int gfs2_meta_wait(struct gfs2_sbd *sdp, struct buffer_head *bh)
D
David Teigland 已提交
256 257 258 259
{
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
		return -EIO;

S
Steven Whitehouse 已提交
260
	wait_on_buffer(bh);
D
David Teigland 已提交
261

S
Steven Whitehouse 已提交
262 263 264 265 266
	if (!buffer_uptodate(bh)) {
		struct gfs2_trans *tr = current->journal_info;
		if (tr && tr->tr_touched)
			gfs2_io_error_bh(sdp, bh);
		return -EIO;
D
David Teigland 已提交
267
	}
S
Steven Whitehouse 已提交
268 269
	if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
		return -EIO;
D
David Teigland 已提交
270 271 272 273 274

	return 0;
}

/**
275
 * gfs2_attach_bufdata - attach a struct gfs2_bufdata structure to a buffer
D
David Teigland 已提交
276 277
 * @gl: the glock the buffer belongs to
 * @bh: The buffer to be attached to
278
 * @meta: Flag to indicate whether its metadata or not
D
David Teigland 已提交
279 280
 */

281 282
void gfs2_attach_bufdata(struct gfs2_glock *gl, struct buffer_head *bh,
			 int meta)
D
David Teigland 已提交
283 284 285
{
	struct gfs2_bufdata *bd;

286 287
	if (meta)
		lock_page(bh->b_page);
D
David Teigland 已提交
288

289
	if (bh->b_private) {
290 291
		if (meta)
			unlock_page(bh->b_page);
D
David Teigland 已提交
292 293 294
		return;
	}

B
Bob Peterson 已提交
295
	bd = kmem_cache_zalloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
296 297 298
	bd->bd_bh = bh;
	bd->bd_gl = gl;

S
Steven Whitehouse 已提交
299
	if (meta)
300
		lops_init_le(bd, &gfs2_buf_lops);
S
Steven Whitehouse 已提交
301
	else
302
		lops_init_le(bd, &gfs2_databuf_lops);
303
	bh->b_private = bd;
D
David Teigland 已提交
304

305 306
	if (meta)
		unlock_page(bh->b_page);
D
David Teigland 已提交
307 308
}

309 310
void gfs2_remove_from_journal(struct buffer_head *bh, struct gfs2_trans *tr, int meta)
{
311 312
	struct address_space *mapping = bh->b_page->mapping;
	struct gfs2_sbd *sdp = gfs2_mapping2sbd(mapping);
313
	struct gfs2_bufdata *bd = bh->b_private;
314

315
	if (test_clear_buffer_pinned(bh)) {
316
		trace_gfs2_pin(bd, 0);
317
		atomic_dec(&sdp->sd_log_pinned);
318
		list_del_init(&bd->bd_list);
319 320 321 322 323 324 325 326 327 328 329 330 331
		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) {
332
		spin_lock(&sdp->sd_ail_lock);
333
		if (bd->bd_ail) {
334
			gfs2_remove_from_ail(bd);
335 336 337 338 339
			bh->b_private = NULL;
			bd->bd_bh = NULL;
			bd->bd_blkno = bh->b_blocknr;
			gfs2_trans_add_revoke(sdp, bd);
		}
340
		spin_unlock(&sdp->sd_ail_lock);
341 342 343 344 345
	}
	clear_buffer_dirty(bh);
	clear_buffer_uptodate(bh);
}

D
David Teigland 已提交
346 347 348 349 350 351 352 353
/**
 * 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
 *
 */

354
void gfs2_meta_wipe(struct gfs2_inode *ip, u64 bstart, u32 blen)
D
David Teigland 已提交
355
{
356
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
357 358 359
	struct buffer_head *bh;

	while (blen) {
360
		bh = gfs2_getbuf(ip->i_gl, bstart, NO_CREATE);
D
David Teigland 已提交
361
		if (bh) {
362 363
			lock_buffer(bh);
			gfs2_log_lock(sdp);
364
			gfs2_remove_from_journal(bh, current->journal_info, 1);
365
			gfs2_log_unlock(sdp);
D
David Teigland 已提交
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
			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
 * @bhp: the buffer is returned here
 *
 * Returns: errno
 */

385
int gfs2_meta_indirect_buffer(struct gfs2_inode *ip, int height, u64 num,
386
			      struct buffer_head **bhp)
D
David Teigland 已提交
387
{
S
Steven Whitehouse 已提交
388 389
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	struct gfs2_glock *gl = ip->i_gl;
390 391
	struct buffer_head *bh;
	int ret = 0;
392
	u32 mtype = height ? GFS2_METATYPE_IN : GFS2_METATYPE_DI;
D
David Teigland 已提交
393

394 395 396 397
	ret = gfs2_meta_read(gl, num, DIO_WAIT, &bh);
	if (ret == 0 && gfs2_metatype_check(sdp, bh, mtype)) {
		brelse(bh);
		ret = -EIO;
D
David Teigland 已提交
398 399
	}
	*bhp = bh;
400
	return ret;
D
David Teigland 已提交
401 402 403 404 405 406 407 408
}

/**
 * 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
 *
S
Steven Whitehouse 已提交
409
 * returns: the first buffer in the extent
D
David Teigland 已提交
410 411
 */

S
Steven Whitehouse 已提交
412
struct buffer_head *gfs2_meta_ra(struct gfs2_glock *gl, u64 dblock, u32 extlen)
D
David Teigland 已提交
413 414 415
{
	struct gfs2_sbd *sdp = gl->gl_sbd;
	struct buffer_head *first_bh, *bh;
416
	u32 max_ra = gfs2_tune_get(sdp, gt_max_readahead) >>
417
			  sdp->sd_sb.sb_bsize_shift;
D
David Teigland 已提交
418

S
Steven Whitehouse 已提交
419 420 421 422
	BUG_ON(!extlen);

	if (max_ra < 1)
		max_ra = 1;
D
David Teigland 已提交
423 424 425
	if (extlen > max_ra)
		extlen = max_ra;

426
	first_bh = gfs2_getbuf(gl, dblock, CREATE);
D
David Teigland 已提交
427 428 429

	if (buffer_uptodate(first_bh))
		goto out;
S
Steven Whitehouse 已提交
430
	if (!buffer_locked(first_bh))
S
Steven Whitehouse 已提交
431
		ll_rw_block(READ_SYNC | REQ_META, 1, &first_bh);
D
David Teigland 已提交
432 433 434 435 436

	dblock++;
	extlen--;

	while (extlen) {
437
		bh = gfs2_getbuf(gl, dblock, CREATE);
D
David Teigland 已提交
438

S
Steven Whitehouse 已提交
439
		if (!buffer_uptodate(bh) && !buffer_locked(bh))
S
Steven Whitehouse 已提交
440
			ll_rw_block(READA | REQ_META, 1, &bh);
S
Steven Whitehouse 已提交
441
		brelse(bh);
D
David Teigland 已提交
442 443
		dblock++;
		extlen--;
S
Steven Whitehouse 已提交
444 445
		if (!buffer_locked(first_bh) && buffer_uptodate(first_bh))
			goto out;
D
David Teigland 已提交
446 447
	}

S
Steven Whitehouse 已提交
448
	wait_on_buffer(first_bh);
449
out:
S
Steven Whitehouse 已提交
450
	return first_bh;
D
David Teigland 已提交
451 452
}