rgrp.c 44.8 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
 */

#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
14
#include <linux/fs.h>
15
#include <linux/gfs2_ondisk.h>
16
#include <linux/prefetch.h>
17
#include <linux/blkdev.h>
18
#include <linux/rbtree.h>
D
David Teigland 已提交
19 20

#include "gfs2.h"
21
#include "incore.h"
D
David Teigland 已提交
22 23 24 25 26 27 28 29
#include "glock.h"
#include "glops.h"
#include "lops.h"
#include "meta_io.h"
#include "quota.h"
#include "rgrp.h"
#include "super.h"
#include "trans.h"
30
#include "util.h"
31
#include "log.h"
32
#include "inode.h"
S
Steven Whitehouse 已提交
33
#include "trace_gfs2.h"
D
David Teigland 已提交
34

S
Steven Whitehouse 已提交
35
#define BFITNOENT ((u32)~0)
36
#define NO_BLOCK ((u64)~0)
37

38 39 40 41 42 43 44 45 46 47
#if BITS_PER_LONG == 32
#define LBITMASK   (0x55555555UL)
#define LBITSKIP55 (0x55555555UL)
#define LBITSKIP00 (0x00000000UL)
#else
#define LBITMASK   (0x5555555555555555UL)
#define LBITSKIP55 (0x5555555555555555UL)
#define LBITSKIP00 (0x0000000000000000UL)
#endif

48 49 50
/*
 * These routines are used by the resource group routines (rgrp.c)
 * to keep track of block allocation.  Each block is represented by two
51 52 53 54 55 56
 * bits.  So, each byte represents GFS2_NBBY (i.e. 4) blocks.
 *
 * 0 = Free
 * 1 = Used (not metadata)
 * 2 = Unlinked (still in use) inode
 * 3 = Used (metadata)
57 58 59 60
 */

static const char valid_change[16] = {
	        /* current */
61
	/* n */ 0, 1, 1, 1,
62
	/* e */ 1, 0, 0, 0,
63
	/* w */ 0, 0, 0, 1,
64 65 66
	        1, 0, 0, 0
};

67
static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
68
			unsigned char old_state,
B
Bob Peterson 已提交
69
			struct gfs2_bitmap **rbi);
70

71 72 73 74 75 76 77 78 79
/**
 * gfs2_setbit - Set a bit in the bitmaps
 * @buffer: the buffer that holds the bitmaps
 * @buflen: the length (in bytes) of the buffer
 * @block: the block to set
 * @new_state: the new state of the block
 *
 */

80 81
static inline void gfs2_setbit(struct gfs2_rgrpd *rgd, unsigned char *buf1,
			       unsigned char *buf2, unsigned int offset,
82
			       struct gfs2_bitmap *bi, u32 block,
83
			       unsigned char new_state)
84
{
85
	unsigned char *byte1, *byte2, *end, cur_state;
86
	unsigned int buflen = bi->bi_len;
87
	const unsigned int bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE;
88

89 90
	byte1 = buf1 + offset + (block / GFS2_NBBY);
	end = buf1 + offset + buflen;
91

92
	BUG_ON(byte1 >= end);
93

94
	cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
95

96
	if (unlikely(!valid_change[new_state * 4 + cur_state])) {
97 98 99 100 101 102 103 104 105 106
		printk(KERN_WARNING "GFS2: buf_blk = 0x%llx old_state=%d, "
		       "new_state=%d\n",
		       (unsigned long long)block, cur_state, new_state);
		printk(KERN_WARNING "GFS2: rgrp=0x%llx bi_start=0x%lx\n",
		       (unsigned long long)rgd->rd_addr,
		       (unsigned long)bi->bi_start);
		printk(KERN_WARNING "GFS2: bi_offset=0x%lx bi_len=0x%lx\n",
		       (unsigned long)bi->bi_offset,
		       (unsigned long)bi->bi_len);
		dump_stack();
107
		gfs2_consist_rgrpd(rgd);
108 109 110 111 112 113 114 115 116
		return;
	}
	*byte1 ^= (cur_state ^ new_state) << bit;

	if (buf2) {
		byte2 = buf2 + offset + (block / GFS2_NBBY);
		cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
		*byte2 ^= (cur_state ^ new_state) << bit;
	}
117 118 119 120 121 122 123 124 125 126
}

/**
 * gfs2_testbit - test a bit in the bitmaps
 * @buffer: the buffer that holds the bitmaps
 * @buflen: the length (in bytes) of the buffer
 * @block: the block to read
 *
 */

127 128 129
static inline unsigned char gfs2_testbit(struct gfs2_rgrpd *rgd,
					 const unsigned char *buffer,
					 unsigned int buflen, u32 block)
130
{
131 132
	const unsigned char *byte, *end;
	unsigned char cur_state;
133 134 135 136 137 138 139 140 141 142 143 144 145
	unsigned int bit;

	byte = buffer + (block / GFS2_NBBY);
	bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE;
	end = buffer + buflen;

	gfs2_assert(rgd->rd_sbd, byte < end);

	cur_state = (*byte >> bit) & GFS2_BIT_MASK;

	return cur_state;
}

146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
/**
 * gfs2_bit_search
 * @ptr: Pointer to bitmap data
 * @mask: Mask to use (normally 0x55555.... but adjusted for search start)
 * @state: The state we are searching for
 *
 * We xor the bitmap data with a patter which is the bitwise opposite
 * of what we are looking for, this gives rise to a pattern of ones
 * wherever there is a match. Since we have two bits per entry, we
 * take this pattern, shift it down by one place and then and it with
 * the original. All the even bit positions (0,2,4, etc) then represent
 * successful matches, so we mask with 0x55555..... to remove the unwanted
 * odd bit positions.
 *
 * This allows searching of a whole u64 at once (32 blocks) with a
 * single test (on 64 bit arches).
 */

static inline u64 gfs2_bit_search(const __le64 *ptr, u64 mask, u8 state)
{
	u64 tmp;
	static const u64 search[] = {
168 169 170 171
		[0] = 0xffffffffffffffffULL,
		[1] = 0xaaaaaaaaaaaaaaaaULL,
		[2] = 0x5555555555555555ULL,
		[3] = 0x0000000000000000ULL,
172 173 174 175 176 177 178
	};
	tmp = le64_to_cpu(*ptr) ^ search[state];
	tmp &= (tmp >> 1);
	tmp &= mask;
	return tmp;
}

179 180 181 182
/**
 * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
 *       a block in a given allocation state.
 * @buffer: the buffer that holds the bitmaps
183
 * @len: the length (in bytes) of the buffer
184
 * @goal: start search at this block's bit-pair (within @buffer)
185
 * @state: GFS2_BLKST_XXX the state of the block we're looking for.
186 187 188
 *
 * Scope of @goal and returned block number is only within this bitmap buffer,
 * not entire rgrp or filesystem.  @buffer will be offset from the actual
189 190 191 192 193
 * beginning of a bitmap block buffer, skipping any header structures, but
 * headers are always a multiple of 64 bits long so that the buffer is
 * always aligned to a 64 bit boundary.
 *
 * The size of the buffer is in bytes, but is it assumed that it is
194
 * always ok to read a complete multiple of 64 bits at the end
195
 * of the block in case the end is no aligned to a natural boundary.
196 197 198 199
 *
 * Return: the block number (bitmap buffer scope) that was found
 */

200 201
static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
		       u32 goal, u8 state)
202
{
203 204 205 206
	u32 spoint = (goal << 1) & ((8*sizeof(u64)) - 1);
	const __le64 *ptr = ((__le64 *)buf) + (goal >> 5);
	const __le64 *end = (__le64 *)(buf + ALIGN(len, sizeof(u64)));
	u64 tmp;
207
	u64 mask = 0x5555555555555555ULL;
208 209 210 211 212 213 214 215 216
	u32 bit;

	BUG_ON(state > 3);

	/* Mask off bits we don't care about at the start of the search */
	mask <<= spoint;
	tmp = gfs2_bit_search(ptr, mask, state);
	ptr++;
	while(tmp == 0 && ptr < end) {
217
		tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
218
		ptr++;
219
	}
220 221 222 223 224 225 226
	/* Mask off any bits which are more than len bytes from the start */
	if (ptr == end && (len & (sizeof(u64) - 1)))
		tmp &= (((u64)~0) >> (64 - 8*(len & (sizeof(u64) - 1))));
	/* Didn't find anything, so return */
	if (tmp == 0)
		return BFITNOENT;
	ptr--;
227
	bit = __ffs64(tmp);
228 229
	bit /= 2;	/* two bits per entry in the bitmap */
	return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
230 231 232 233 234 235 236 237 238 239 240
}

/**
 * gfs2_bitcount - count the number of bits in a certain state
 * @buffer: the buffer that holds the bitmaps
 * @buflen: the length (in bytes) of the buffer
 * @state: the state of the block we're looking for
 *
 * Returns: The number of bits
 */

241 242
static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
			 unsigned int buflen, u8 state)
243
{
244 245 246 247 248
	const u8 *byte = buffer;
	const u8 *end = buffer + buflen;
	const u8 state1 = state << 2;
	const u8 state2 = state << 4;
	const u8 state3 = state << 6;
249
	u32 count = 0;
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264

	for (; byte < end; byte++) {
		if (((*byte) & 0x03) == state)
			count++;
		if (((*byte) & 0x0C) == state1)
			count++;
		if (((*byte) & 0x30) == state2)
			count++;
		if (((*byte) & 0xC0) == state3)
			count++;
	}

	return count;
}

D
David Teigland 已提交
265 266 267 268 269 270 271 272 273 274 275
/**
 * gfs2_rgrp_verify - Verify that a resource group is consistent
 * @sdp: the filesystem
 * @rgd: the rgrp
 *
 */

void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct gfs2_bitmap *bi = NULL;
276
	u32 length = rgd->rd_length;
277
	u32 count[4], tmp;
D
David Teigland 已提交
278 279
	int buf, x;

280
	memset(count, 0, 4 * sizeof(u32));
D
David Teigland 已提交
281 282 283 284 285 286 287 288 289 290 291

	/* Count # blocks in each of 4 possible allocation states */
	for (buf = 0; buf < length; buf++) {
		bi = rgd->rd_bits + buf;
		for (x = 0; x < 4; x++)
			count[x] += gfs2_bitcount(rgd,
						  bi->bi_bh->b_data +
						  bi->bi_offset,
						  bi->bi_len, x);
	}

292
	if (count[0] != rgd->rd_free) {
D
David Teigland 已提交
293 294
		if (gfs2_consist_rgrpd(rgd))
			fs_err(sdp, "free data mismatch:  %u != %u\n",
295
			       count[0], rgd->rd_free);
D
David Teigland 已提交
296 297 298
		return;
	}

299
	tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
300
	if (count[1] != tmp) {
D
David Teigland 已提交
301 302 303 304 305 306
		if (gfs2_consist_rgrpd(rgd))
			fs_err(sdp, "used data mismatch:  %u != %u\n",
			       count[1], tmp);
		return;
	}

307
	if (count[2] + count[3] != rgd->rd_dinodes) {
D
David Teigland 已提交
308
		if (gfs2_consist_rgrpd(rgd))
309
			fs_err(sdp, "used metadata mismatch:  %u != %u\n",
310
			       count[2] + count[3], rgd->rd_dinodes);
D
David Teigland 已提交
311 312 313 314
		return;
	}
}

315
static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block)
D
David Teigland 已提交
316
{
317 318
	u64 first = rgd->rd_data0;
	u64 last = first + rgd->rd_data;
319
	return first <= block && block < last;
D
David Teigland 已提交
320 321 322 323 324 325 326 327 328 329
}

/**
 * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
 * @sdp: The GFS2 superblock
 * @n: The data block number
 *
 * Returns: The resource group, or NULL if not found
 */

S
Steven Whitehouse 已提交
330
struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
D
David Teigland 已提交
331
{
S
Steven Whitehouse 已提交
332
	struct rb_node *n, *next;
333
	struct gfs2_rgrpd *cur;
D
David Teigland 已提交
334 335

	spin_lock(&sdp->sd_rindex_spin);
S
Steven Whitehouse 已提交
336 337 338 339
	n = sdp->sd_rindex_tree.rb_node;
	while (n) {
		cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
		next = NULL;
340
		if (blk < cur->rd_addr)
S
Steven Whitehouse 已提交
341
			next = n->rb_left;
342
		else if (blk >= cur->rd_data0 + cur->rd_data)
S
Steven Whitehouse 已提交
343 344
			next = n->rb_right;
		if (next == NULL) {
D
David Teigland 已提交
345
			spin_unlock(&sdp->sd_rindex_spin);
S
Steven Whitehouse 已提交
346 347 348 349 350 351
			if (exact) {
				if (blk < cur->rd_addr)
					return NULL;
				if (blk >= cur->rd_data0 + cur->rd_data)
					return NULL;
			}
352
			return cur;
D
David Teigland 已提交
353
		}
S
Steven Whitehouse 已提交
354
		n = next;
D
David Teigland 已提交
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
	}
	spin_unlock(&sdp->sd_rindex_spin);

	return NULL;
}

/**
 * gfs2_rgrpd_get_first - get the first Resource Group in the filesystem
 * @sdp: The GFS2 superblock
 *
 * Returns: The first rgrp in the filesystem
 */

struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp)
{
370 371 372
	const struct rb_node *n;
	struct gfs2_rgrpd *rgd;

373
	spin_lock(&sdp->sd_rindex_spin);
374 375
	n = rb_first(&sdp->sd_rindex_tree);
	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
376
	spin_unlock(&sdp->sd_rindex_spin);
377 378

	return rgd;
D
David Teigland 已提交
379 380 381 382 383 384 385 386 387 388 389
}

/**
 * gfs2_rgrpd_get_next - get the next RG
 * @rgd: A RG
 *
 * Returns: The next rgrp
 */

struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
{
390 391 392 393 394 395 396 397 398 399
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	const struct rb_node *n;

	spin_lock(&sdp->sd_rindex_spin);
	n = rb_next(&rgd->rd_node);
	if (n == NULL)
		n = rb_first(&sdp->sd_rindex_tree);

	if (unlikely(&rgd->rd_node == n)) {
		spin_unlock(&sdp->sd_rindex_spin);
D
David Teigland 已提交
400
		return NULL;
401 402 403 404
	}
	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
	spin_unlock(&sdp->sd_rindex_spin);
	return rgd;
D
David Teigland 已提交
405 406
}

407 408 409 410 411 412 413 414 415 416 417 418
void gfs2_free_clones(struct gfs2_rgrpd *rgd)
{
	int x;

	for (x = 0; x < rgd->rd_length; x++) {
		struct gfs2_bitmap *bi = rgd->rd_bits + x;
		kfree(bi->bi_clone);
		bi->bi_clone = NULL;
	}
}

void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
D
David Teigland 已提交
419
{
420
	struct rb_node *n;
D
David Teigland 已提交
421 422 423
	struct gfs2_rgrpd *rgd;
	struct gfs2_glock *gl;

424 425
	while ((n = rb_first(&sdp->sd_rindex_tree))) {
		rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
D
David Teigland 已提交
426 427
		gl = rgd->rd_gl;

428
		rb_erase(n, &sdp->sd_rindex_tree);
D
David Teigland 已提交
429 430

		if (gl) {
431
			spin_lock(&gl->gl_spin);
432
			gl->gl_object = NULL;
433
			spin_unlock(&gl->gl_spin);
434
			gfs2_glock_add_to_lru(gl);
D
David Teigland 已提交
435 436 437
			gfs2_glock_put(gl);
		}

438
		gfs2_free_clones(rgd);
D
David Teigland 已提交
439
		kfree(rgd->rd_bits);
440
		kmem_cache_free(gfs2_rgrpd_cachep, rgd);
D
David Teigland 已提交
441 442 443
	}
}

444 445 446 447 448 449 450 451 452
static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd)
{
	printk(KERN_INFO "  ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
	printk(KERN_INFO "  ri_length = %u\n", rgd->rd_length);
	printk(KERN_INFO "  ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
	printk(KERN_INFO "  ri_data = %u\n", rgd->rd_data);
	printk(KERN_INFO "  ri_bitbytes = %u\n", rgd->rd_bitbytes);
}

D
David Teigland 已提交
453 454 455 456 457 458 459 460 461 462 463 464 465
/**
 * gfs2_compute_bitstructs - Compute the bitmap sizes
 * @rgd: The resource group descriptor
 *
 * Calculates bitmap descriptors, one for each block that contains bitmap data
 *
 * Returns: errno
 */

static int compute_bitstructs(struct gfs2_rgrpd *rgd)
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct gfs2_bitmap *bi;
466
	u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
467
	u32 bytes_left, bytes;
D
David Teigland 已提交
468 469
	int x;

470 471 472
	if (!length)
		return -EINVAL;

473
	rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
D
David Teigland 已提交
474 475 476
	if (!rgd->rd_bits)
		return -ENOMEM;

477
	bytes_left = rgd->rd_bitbytes;
D
David Teigland 已提交
478 479 480 481

	for (x = 0; x < length; x++) {
		bi = rgd->rd_bits + x;

482
		bi->bi_flags = 0;
D
David Teigland 已提交
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
		/* small rgrp; bitmap stored completely in header block */
		if (length == 1) {
			bytes = bytes_left;
			bi->bi_offset = sizeof(struct gfs2_rgrp);
			bi->bi_start = 0;
			bi->bi_len = bytes;
		/* header block */
		} else if (x == 0) {
			bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
			bi->bi_offset = sizeof(struct gfs2_rgrp);
			bi->bi_start = 0;
			bi->bi_len = bytes;
		/* last block */
		} else if (x + 1 == length) {
			bytes = bytes_left;
			bi->bi_offset = sizeof(struct gfs2_meta_header);
499
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
D
David Teigland 已提交
500 501 502
			bi->bi_len = bytes;
		/* other blocks */
		} else {
503 504
			bytes = sdp->sd_sb.sb_bsize -
				sizeof(struct gfs2_meta_header);
D
David Teigland 已提交
505
			bi->bi_offset = sizeof(struct gfs2_meta_header);
506
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
D
David Teigland 已提交
507 508 509 510 511 512 513 514 515 516 517
			bi->bi_len = bytes;
		}

		bytes_left -= bytes;
	}

	if (bytes_left) {
		gfs2_consist_rgrpd(rgd);
		return -EIO;
	}
	bi = rgd->rd_bits + (length - 1);
518
	if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
D
David Teigland 已提交
519
		if (gfs2_consist_rgrpd(rgd)) {
520
			gfs2_rindex_print(rgd);
D
David Teigland 已提交
521 522 523 524 525 526 527 528 529
			fs_err(sdp, "start=%u len=%u offset=%u\n",
			       bi->bi_start, bi->bi_len, bi->bi_offset);
		}
		return -EIO;
	}

	return 0;
}

530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
/**
 * gfs2_ri_total - Total up the file system space, according to the rindex.
 *
 */
u64 gfs2_ri_total(struct gfs2_sbd *sdp)
{
	u64 total_data = 0;	
	struct inode *inode = sdp->sd_rindex;
	struct gfs2_inode *ip = GFS2_I(inode);
	char buf[sizeof(struct gfs2_rindex)];
	struct file_ra_state ra_state;
	int error, rgrps;

	file_ra_state_init(&ra_state, inode->i_mapping);
	for (rgrps = 0;; rgrps++) {
		loff_t pos = rgrps * sizeof(struct gfs2_rindex);

547
		if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
548 549 550 551 552
			break;
		error = gfs2_internal_read(ip, &ra_state, buf, &pos,
					   sizeof(struct gfs2_rindex));
		if (error != sizeof(struct gfs2_rindex))
			break;
553
		total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
554 555 556 557
	}
	return total_data;
}

B
Bob Peterson 已提交
558
static int rgd_insert(struct gfs2_rgrpd *rgd)
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct rb_node **newn = &sdp->sd_rindex_tree.rb_node, *parent = NULL;

	/* Figure out where to put new node */
	while (*newn) {
		struct gfs2_rgrpd *cur = rb_entry(*newn, struct gfs2_rgrpd,
						  rd_node);

		parent = *newn;
		if (rgd->rd_addr < cur->rd_addr)
			newn = &((*newn)->rb_left);
		else if (rgd->rd_addr > cur->rd_addr)
			newn = &((*newn)->rb_right);
		else
B
Bob Peterson 已提交
574
			return -EEXIST;
575 576 577 578
	}

	rb_link_node(&rgd->rd_node, parent, newn);
	rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
B
Bob Peterson 已提交
579 580
	sdp->sd_rgrps++;
	return 0;
581 582
}

D
David Teigland 已提交
583
/**
584
 * read_rindex_entry - Pull in a new resource index entry from the disk
D
David Teigland 已提交
585 586
 * @gl: The glock covering the rindex inode
 *
587
 * Returns: 0 on success, > 0 on EOF, error code otherwise
588 589 590 591 592 593 594
 */

static int read_rindex_entry(struct gfs2_inode *ip,
			     struct file_ra_state *ra_state)
{
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
595
	struct gfs2_rindex buf;
596 597 598
	int error;
	struct gfs2_rgrpd *rgd;

599 600 601 602
	if (pos >= i_size_read(&ip->i_inode))
		return 1;

	error = gfs2_internal_read(ip, ra_state, (char *)&buf, &pos,
603
				   sizeof(struct gfs2_rindex));
604 605 606

	if (error != sizeof(struct gfs2_rindex))
		return (error == 0) ? 1 : error;
607

608
	rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
609 610 611 612 613
	error = -ENOMEM;
	if (!rgd)
		return error;

	rgd->rd_sbd = sdp;
614 615 616 617 618
	rgd->rd_addr = be64_to_cpu(buf.ri_addr);
	rgd->rd_length = be32_to_cpu(buf.ri_length);
	rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
	rgd->rd_data = be32_to_cpu(buf.ri_data);
	rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
619

620 621
	error = compute_bitstructs(rgd);
	if (error)
622
		goto fail;
623

624
	error = gfs2_glock_get(sdp, rgd->rd_addr,
625 626
			       &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
	if (error)
627
		goto fail;
628 629

	rgd->rd_gl->gl_object = rgd;
630
	rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
631 632
	if (rgd->rd_data > sdp->sd_max_rg_data)
		sdp->sd_max_rg_data = rgd->rd_data;
633
	spin_lock(&sdp->sd_rindex_spin);
B
Bob Peterson 已提交
634
	error = rgd_insert(rgd);
635
	spin_unlock(&sdp->sd_rindex_spin);
B
Bob Peterson 已提交
636 637 638 639
	if (!error)
		return 0;

	error = 0; /* someone else read in the rgrp; free it and ignore it */
640
	gfs2_glock_put(rgd->rd_gl);
641 642 643 644

fail:
	kfree(rgd->rd_bits);
	kmem_cache_free(gfs2_rgrpd_cachep, rgd);
645 646 647 648 649 650 651
	return error;
}

/**
 * gfs2_ri_update - Pull in a new resource index from the disk
 * @ip: pointer to the rindex inode
 *
D
David Teigland 已提交
652 653 654
 * Returns: 0 on successful update, error code otherwise
 */

655
static int gfs2_ri_update(struct gfs2_inode *ip)
D
David Teigland 已提交
656
{
657 658
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	struct inode *inode = &ip->i_inode;
659
	struct file_ra_state ra_state;
D
David Teigland 已提交
660 661
	int error;

662
	file_ra_state_init(&ra_state, inode->i_mapping);
663
	do {
664
		error = read_rindex_entry(ip, &ra_state);
665 666 667 668
	} while (error == 0);

	if (error < 0)
		return error;
D
David Teigland 已提交
669

670
	sdp->sd_rindex_uptodate = 1;
671 672
	return 0;
}
D
David Teigland 已提交
673 674

/**
675
 * gfs2_rindex_update - Update the rindex if required
D
David Teigland 已提交
676 677 678 679 680 681 682 683 684 685 686 687
 * @sdp: The GFS2 superblock
 *
 * We grab a lock on the rindex inode to make sure that it doesn't
 * change whilst we are performing an operation. We keep this lock
 * for quite long periods of time compared to other locks. This
 * doesn't matter, since it is shared and it is very, very rarely
 * accessed in the exclusive mode (i.e. only when expanding the filesystem).
 *
 * This makes sure that we're using the latest copy of the resource index
 * special file, which might have been updated if someone expanded the
 * filesystem (via gfs2_grow utility), which adds new resource groups.
 *
688
 * Returns: 0 on succeess, error code otherwise
D
David Teigland 已提交
689 690
 */

691
int gfs2_rindex_update(struct gfs2_sbd *sdp)
D
David Teigland 已提交
692
{
693
	struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
D
David Teigland 已提交
694
	struct gfs2_glock *gl = ip->i_gl;
695 696
	struct gfs2_holder ri_gh;
	int error = 0;
697
	int unlock_required = 0;
D
David Teigland 已提交
698 699

	/* Read new copy from disk if we don't have the latest */
700
	if (!sdp->sd_rindex_uptodate) {
701 702 703
		if (!gfs2_glock_is_locked_by_me(gl)) {
			error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, &ri_gh);
			if (error)
B
Bob Peterson 已提交
704
				return error;
705 706
			unlock_required = 1;
		}
707
		if (!sdp->sd_rindex_uptodate)
D
David Teigland 已提交
708
			error = gfs2_ri_update(ip);
709 710
		if (unlock_required)
			gfs2_glock_dq_uninit(&ri_gh);
D
David Teigland 已提交
711 712 713 714 715
	}

	return error;
}

716
static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
717 718
{
	const struct gfs2_rgrp *str = buf;
719
	u32 rg_flags;
720

721
	rg_flags = be32_to_cpu(str->rg_flags);
722
	rg_flags &= ~GFS2_RDF_MASK;
723 724
	rgd->rd_flags &= GFS2_RDF_MASK;
	rgd->rd_flags |= rg_flags;
725
	rgd->rd_free = be32_to_cpu(str->rg_free);
726
	rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
727
	rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
728 729
}

730
static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
731 732 733
{
	struct gfs2_rgrp *str = buf;

734
	str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
735
	str->rg_free = cpu_to_be32(rgd->rd_free);
736
	str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
737
	str->__pad = cpu_to_be32(0);
738
	str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
739 740 741
	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
}

D
David Teigland 已提交
742
/**
743
 * gfs2_rgrp_go_lock - Read in a RG's header and bitmaps
D
David Teigland 已提交
744 745 746 747 748 749 750 751
 * @rgd: the struct gfs2_rgrpd describing the RG to read in
 *
 * Read in all of a Resource Group's header and bitmap blocks.
 * Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.
 *
 * Returns: errno
 */

752
int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
D
David Teigland 已提交
753
{
754
	struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
D
David Teigland 已提交
755 756
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct gfs2_glock *gl = rgd->rd_gl;
757
	unsigned int length = rgd->rd_length;
D
David Teigland 已提交
758 759 760 761 762 763
	struct gfs2_bitmap *bi;
	unsigned int x, y;
	int error;

	for (x = 0; x < length; x++) {
		bi = rgd->rd_bits + x;
764
		error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
D
David Teigland 已提交
765 766 767 768 769 770
		if (error)
			goto fail;
	}

	for (y = length; y--;) {
		bi = rgd->rd_bits + y;
S
Steven Whitehouse 已提交
771
		error = gfs2_meta_wait(sdp, bi->bi_bh);
D
David Teigland 已提交
772 773
		if (error)
			goto fail;
774
		if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
D
David Teigland 已提交
775 776 777 778 779 780
					      GFS2_METATYPE_RG)) {
			error = -EIO;
			goto fail;
		}
	}

781
	if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
782 783
		for (x = 0; x < length; x++)
			clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
784
		gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
785
		rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
786
		rgd->rd_free_clone = rgd->rd_free;
D
David Teigland 已提交
787 788 789 790
	}

	return 0;

791
fail:
D
David Teigland 已提交
792 793 794 795 796 797 798 799 800 801 802
	while (x--) {
		bi = rgd->rd_bits + x;
		brelse(bi->bi_bh);
		bi->bi_bh = NULL;
		gfs2_assert_warn(sdp, !bi->bi_clone);
	}

	return error;
}

/**
803
 * gfs2_rgrp_go_unlock - Release RG bitmaps read in with gfs2_rgrp_bh_get()
D
David Teigland 已提交
804 805 806 807
 * @rgd: the struct gfs2_rgrpd describing the RG to read in
 *
 */

808
void gfs2_rgrp_go_unlock(struct gfs2_holder *gh)
D
David Teigland 已提交
809
{
810
	struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
811
	int x, length = rgd->rd_length;
D
David Teigland 已提交
812 813 814 815 816 817 818 819 820

	for (x = 0; x < length; x++) {
		struct gfs2_bitmap *bi = rgd->rd_bits + x;
		brelse(bi->bi_bh);
		bi->bi_bh = NULL;
	}

}

S
Steven Whitehouse 已提交
821
int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
822
			     struct buffer_head *bh,
S
Steven Whitehouse 已提交
823
			     const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
824 825 826 827
{
	struct super_block *sb = sdp->sd_vfs;
	struct block_device *bdev = sb->s_bdev;
	const unsigned int sects_per_blk = sdp->sd_sb.sb_bsize /
828
					   bdev_logical_block_size(sb->s_bdev);
829
	u64 blk;
830
	sector_t start = 0;
831 832 833
	sector_t nr_sects = 0;
	int rv;
	unsigned int x;
S
Steven Whitehouse 已提交
834 835
	u32 trimmed = 0;
	u8 diff;
836 837

	for (x = 0; x < bi->bi_len; x++) {
S
Steven Whitehouse 已提交
838 839 840 841 842 843 844 845 846
		const u8 *clone = bi->bi_clone ? bi->bi_clone : bi->bi_bh->b_data;
		clone += bi->bi_offset;
		clone += x;
		if (bh) {
			const u8 *orig = bh->b_data + bi->bi_offset + x;
			diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));
		} else {
			diff = ~(*clone | (*clone >> 1));
		}
847 848 849 850 851 852 853 854 855 856
		diff &= 0x55;
		if (diff == 0)
			continue;
		blk = offset + ((bi->bi_start + x) * GFS2_NBBY);
		blk *= sects_per_blk; /* convert to sectors */
		while(diff) {
			if (diff & 1) {
				if (nr_sects == 0)
					goto start_new_extent;
				if ((start + nr_sects) != blk) {
S
Steven Whitehouse 已提交
857 858 859 860 861 862 863 864
					if (nr_sects >= minlen) {
						rv = blkdev_issue_discard(bdev,
							start, nr_sects,
							GFP_NOFS, 0);
						if (rv)
							goto fail;
						trimmed += nr_sects;
					}
865 866 867 868 869 870 871 872 873 874
					nr_sects = 0;
start_new_extent:
					start = blk;
				}
				nr_sects += sects_per_blk;
			}
			diff >>= 2;
			blk += sects_per_blk;
		}
	}
S
Steven Whitehouse 已提交
875
	if (nr_sects >= minlen) {
876
		rv = blkdev_issue_discard(bdev, start, nr_sects, GFP_NOFS, 0);
877 878
		if (rv)
			goto fail;
S
Steven Whitehouse 已提交
879
		trimmed += nr_sects;
880
	}
S
Steven Whitehouse 已提交
881 882 883 884
	if (ptrimmed)
		*ptrimmed = trimmed;
	return 0;

885
fail:
S
Steven Whitehouse 已提交
886 887
	if (sdp->sd_args.ar_discard)
		fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem", rv);
888
	sdp->sd_args.ar_discard = 0;
S
Steven Whitehouse 已提交
889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927
	return -EIO;
}

/**
 * gfs2_fitrim - Generate discard requests for unused bits of the filesystem
 * @filp: Any file on the filesystem
 * @argp: Pointer to the arguments (also used to pass result)
 *
 * Returns: 0 on success, otherwise error code
 */

int gfs2_fitrim(struct file *filp, void __user *argp)
{
	struct inode *inode = filp->f_dentry->d_inode;
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	struct request_queue *q = bdev_get_queue(sdp->sd_vfs->s_bdev);
	struct buffer_head *bh;
	struct gfs2_rgrpd *rgd;
	struct gfs2_rgrpd *rgd_end;
	struct gfs2_holder gh;
	struct fstrim_range r;
	int ret = 0;
	u64 amt;
	u64 trimmed = 0;
	unsigned int x;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	if (!blk_queue_discard(q))
		return -EOPNOTSUPP;

	if (argp == NULL) {
		r.start = 0;
		r.len = ULLONG_MAX;
		r.minlen = 0;
	} else if (copy_from_user(&r, argp, sizeof(r)))
		return -EFAULT;

928 929 930 931
	ret = gfs2_rindex_update(sdp);
	if (ret)
		return ret;

S
Steven Whitehouse 已提交
932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976
	rgd = gfs2_blk2rgrpd(sdp, r.start, 0);
	rgd_end = gfs2_blk2rgrpd(sdp, r.start + r.len, 0);

	while (1) {

		ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
		if (ret)
			goto out;

		if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
			/* Trim each bitmap in the rgrp */
			for (x = 0; x < rgd->rd_length; x++) {
				struct gfs2_bitmap *bi = rgd->rd_bits + x;
				ret = gfs2_rgrp_send_discards(sdp, rgd->rd_data0, NULL, bi, r.minlen, &amt);
				if (ret) {
					gfs2_glock_dq_uninit(&gh);
					goto out;
				}
				trimmed += amt;
			}

			/* Mark rgrp as having been trimmed */
			ret = gfs2_trans_begin(sdp, RES_RG_HDR, 0);
			if (ret == 0) {
				bh = rgd->rd_bits[0].bi_bh;
				rgd->rd_flags |= GFS2_RGF_TRIMMED;
				gfs2_trans_add_bh(rgd->rd_gl, bh, 1);
				gfs2_rgrp_out(rgd, bh->b_data);
				gfs2_trans_end(sdp);
			}
		}
		gfs2_glock_dq_uninit(&gh);

		if (rgd == rgd_end)
			break;

		rgd = gfs2_rgrpd_get_next(rgd);
	}

out:
	r.len = trimmed << 9;
	if (argp && copy_to_user(argp, &r, sizeof(r)))
		return -EFAULT;

	return ret;
977 978
}

D
David Teigland 已提交
979
/**
980
 * gfs2_qadata_get - get the struct gfs2_qadata structure for an inode
D
David Teigland 已提交
981 982
 * @ip: the incore GFS2 inode structure
 *
983
 * Returns: the struct gfs2_qadata
D
David Teigland 已提交
984 985
 */

986
struct gfs2_qadata *gfs2_qadata_get(struct gfs2_inode *ip)
D
David Teigland 已提交
987
{
988 989
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	int error;
990 991
	BUG_ON(ip->i_qadata != NULL);
	ip->i_qadata = kzalloc(sizeof(struct gfs2_qadata), GFP_NOFS);
992 993 994
	error = gfs2_rindex_update(sdp);
	if (error)
		fs_warn(sdp, "rindex update returns %d\n", error);
995 996 997 998 999 1000 1001 1002 1003 1004
	return ip->i_qadata;
}

/**
 * gfs2_blkrsv_get - get the struct gfs2_blkreserv structure for an inode
 * @ip: the incore GFS2 inode structure
 *
 * Returns: the struct gfs2_qadata
 */

1005
static int gfs2_blkrsv_get(struct gfs2_inode *ip)
1006 1007
{
	BUG_ON(ip->i_res != NULL);
1008 1009 1010 1011
	ip->i_res = kmem_cache_zalloc(gfs2_rsrv_cachep, GFP_NOFS);
	if (!ip->i_res)
		return -ENOMEM;
	return 0;
D
David Teigland 已提交
1012 1013 1014 1015 1016
}

/**
 * try_rgrp_fit - See if a given reservation will fit in a given RG
 * @rgd: the RG data
1017
 * @ip: the inode
D
David Teigland 已提交
1018 1019 1020 1021 1022 1023
 *
 * If there's room for the requested blocks to be allocated from the RG:
 *
 * Returns: 1 on success (it fits), 0 on failure (it doesn't fit)
 */

1024
static int try_rgrp_fit(const struct gfs2_rgrpd *rgd, const struct gfs2_inode *ip)
D
David Teigland 已提交
1025
{
1026
	const struct gfs2_blkreserv *rs = ip->i_res;
1027

1028
	if (rgd->rd_flags & (GFS2_RGF_NOALLOC | GFS2_RDF_ERROR))
1029
		return 0;
1030
	if (rgd->rd_free_clone >= rs->rs_requested)
1031 1032
		return 1;
	return 0;
D
David Teigland 已提交
1033 1034
}

B
Bob Peterson 已提交
1035 1036 1037 1038 1039
static inline u32 gfs2_bi2rgd_blk(struct gfs2_bitmap *bi, u32 blk)
{
	return (bi->bi_start * GFS2_NBBY) + blk;
}

1040 1041 1042 1043
/**
 * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
 * @rgd: The rgrp
 *
B
Bob Peterson 已提交
1044 1045
 * Returns: 0 if no error
 *          The inode, if one has been found, in inode.
1046 1047
 */

1048
static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
1049
{
1050
	u32 goal = 0, block;
1051
	u64 no_addr;
1052
	struct gfs2_sbd *sdp = rgd->rd_sbd;
1053 1054 1055 1056
	struct gfs2_glock *gl;
	struct gfs2_inode *ip;
	int error;
	int found = 0;
B
Bob Peterson 已提交
1057
	struct gfs2_bitmap *bi;
1058

1059
	while (goal < rgd->rd_data) {
1060
		down_write(&sdp->sd_log_flush_lock);
1061
		block = rgblk_search(rgd, goal, GFS2_BLKST_UNLINKED, &bi);
1062
		up_write(&sdp->sd_log_flush_lock);
1063
		if (block == BFITNOENT)
1064
			break;
B
Bob Peterson 已提交
1065 1066

		block = gfs2_bi2rgd_blk(bi, block);
1067 1068 1069
		/* rgblk_search can return a block < goal, so we need to
		   keep it marching forward. */
		no_addr = block + rgd->rd_data0;
1070
		goal = max(block + 1, goal + 1);
1071
		if (*last_unlinked != NO_BLOCK && no_addr <= *last_unlinked)
1072
			continue;
1073 1074
		if (no_addr == skip)
			continue;
1075
		*last_unlinked = no_addr;
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095

		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &gl);
		if (error)
			continue;

		/* If the inode is already in cache, we can ignore it here
		 * because the existing inode disposal code will deal with
		 * it when all refs have gone away. Accessing gl_object like
		 * this is not safe in general. Here it is ok because we do
		 * not dereference the pointer, and we only need an approx
		 * answer to whether it is NULL or not.
		 */
		ip = gl->gl_object;

		if (ip || queue_work(gfs2_delete_workqueue, &gl->gl_delete) == 0)
			gfs2_glock_put(gl);
		else
			found++;

		/* Limit reclaim to sensible number of tasks */
1096
		if (found > NR_CPUS)
1097
			return;
1098 1099 1100
	}

	rgd->rd_flags &= ~GFS2_RDF_CHECK;
1101
	return;
1102 1103
}

D
David Teigland 已提交
1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
/**
 * get_local_rgrp - Choose and lock a rgrp for allocation
 * @ip: the inode to reserve space for
 * @rgp: the chosen and locked rgrp
 *
 * Try to acquire rgrp in way which avoids contending with others.
 *
 * Returns: errno
 */

1114
static int get_local_rgrp(struct gfs2_inode *ip, u64 *last_unlinked)
D
David Teigland 已提交
1115
{
1116
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
1117
	struct gfs2_rgrpd *rgd, *begin = NULL;
1118
	struct gfs2_blkreserv *rs = ip->i_res;
1119
	int error, rg_locked, flags = LM_FLAG_TRY;
1120
	int loops = 0;
D
David Teigland 已提交
1121

1122 1123 1124
	if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, ip->i_goal))
		rgd = begin = ip->i_rgd;
	else
S
Steven Whitehouse 已提交
1125
		rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
D
David Teigland 已提交
1126

1127 1128 1129 1130
	if (rgd == NULL)
		return -EBADSLT;

	while (loops < 3) {
1131 1132 1133 1134 1135 1136 1137
		rg_locked = 0;

		if (gfs2_glock_is_locked_by_me(rgd->rd_gl)) {
			rg_locked = 1;
			error = 0;
		} else {
			error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
1138
						   flags, &rs->rs_rgd_gh);
1139
		}
D
David Teigland 已提交
1140 1141
		switch (error) {
		case 0:
1142 1143
			if (try_rgrp_fit(rgd, ip)) {
				ip->i_rgd = rgd;
1144
				return 0;
1145
			}
1146 1147
			if (rgd->rd_flags & GFS2_RDF_CHECK)
				try_rgrp_unlink(rgd, last_unlinked, ip->i_no_addr);
1148
			if (!rg_locked)
1149
				gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1150
			/* fall through */
D
David Teigland 已提交
1151
		case GLR_TRYFAILED:
1152
			rgd = gfs2_rgrpd_get_next(rgd);
1153 1154
			if (rgd == begin) {
				flags = 0;
1155
				loops++;
1156
			}
D
David Teigland 已提交
1157 1158
			break;
		default:
1159
			return error;
D
David Teigland 已提交
1160 1161 1162
		}
	}

1163
	return -ENOSPC;
D
David Teigland 已提交
1164 1165
}

1166 1167 1168
static void gfs2_blkrsv_put(struct gfs2_inode *ip)
{
	BUG_ON(ip->i_res == NULL);
1169
	kmem_cache_free(gfs2_rsrv_cachep, ip->i_res);
1170 1171 1172
	ip->i_res = NULL;
}

D
David Teigland 已提交
1173
/**
1174
 * gfs2_inplace_reserve - Reserve space in the filesystem
D
David Teigland 已提交
1175 1176 1177 1178 1179
 * @ip: the inode to reserve space for
 *
 * Returns: errno
 */

1180
int gfs2_inplace_reserve(struct gfs2_inode *ip, u32 requested)
D
David Teigland 已提交
1181
{
1182
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1183
	struct gfs2_blkreserv *rs;
1184
	int error;
1185 1186
	u64 last_unlinked = NO_BLOCK;
	int tries = 0;
D
David Teigland 已提交
1187

1188 1189 1190
	error = gfs2_blkrsv_get(ip);
	if (error)
		return error;
1191

1192
	rs = ip->i_res;
1193 1194 1195 1196 1197
	rs->rs_requested = requested;
	if (gfs2_assert_warn(sdp, requested)) {
		error = -EINVAL;
		goto out;
	}
D
David Teigland 已提交
1198

1199 1200
	do {
		error = get_local_rgrp(ip, &last_unlinked);
1201 1202 1203 1204 1205 1206 1207 1208
		if (error != -ENOSPC)
			break;
		/* Check that fs hasn't grown if writing to rindex */
		if (ip == GFS2_I(sdp->sd_rindex) && !sdp->sd_rindex_uptodate) {
			error = gfs2_ri_update(ip);
			if (error)
				break;
			continue;
1209
		}
1210 1211 1212
		/* Flushing the log may release space */
		gfs2_log_flush(sdp, NULL);
	} while (tries++ < 3);
D
David Teigland 已提交
1213

1214 1215 1216
out:
	if (error)
		gfs2_blkrsv_put(ip);
1217
	return error;
D
David Teigland 已提交
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
}

/**
 * gfs2_inplace_release - release an inplace reservation
 * @ip: the inode the reservation was taken out on
 *
 * Release a reservation made by gfs2_inplace_reserve().
 */

void gfs2_inplace_release(struct gfs2_inode *ip)
{
1229
	struct gfs2_blkreserv *rs = ip->i_res;
D
David Teigland 已提交
1230

1231 1232
	if (rs->rs_rgd_gh.gh_gl)
		gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1233
	gfs2_blkrsv_put(ip);
D
David Teigland 已提交
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
}

/**
 * gfs2_get_block_type - Check a block in a RG is of given type
 * @rgd: the resource group holding the block
 * @block: the block number
 *
 * Returns: The block type (GFS2_BLKST_*)
 */

1244
static unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
D
David Teigland 已提交
1245 1246
{
	struct gfs2_bitmap *bi = NULL;
1247
	u32 length, rgrp_block, buf_block;
D
David Teigland 已提交
1248 1249 1250
	unsigned int buf;
	unsigned char type;

1251 1252
	length = rgd->rd_length;
	rgrp_block = block - rgd->rd_data0;
D
David Teigland 已提交
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262

	for (buf = 0; buf < length; buf++) {
		bi = rgd->rd_bits + buf;
		if (rgrp_block < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
			break;
	}

	gfs2_assert(rgd->rd_sbd, buf < length);
	buf_block = rgrp_block - bi->bi_start * GFS2_NBBY;

1263
	type = gfs2_testbit(rgd, bi->bi_bh->b_data + bi->bi_offset,
D
David Teigland 已提交
1264 1265 1266 1267 1268 1269
			   bi->bi_len, buf_block);

	return type;
}

/**
1270
 * rgblk_search - find a block in @state
D
David Teigland 已提交
1271 1272
 * @rgd: the resource group descriptor
 * @goal: the goal block within the RG (start here to search for avail block)
1273
 * @state: GFS2_BLKST_XXX the before-allocation state to find
1274
 * @dinode: TRUE if the first block we allocate is for a dinode
B
Bob Peterson 已提交
1275
 * @rbi: address of the pointer to the bitmap containing the block found
D
David Teigland 已提交
1276
 *
1277
 * Walk rgrp's bitmap to find bits that represent a block in @state.
D
David Teigland 已提交
1278 1279 1280 1281
 *
 * This function never fails, because we wouldn't call it unless we
 * know (from reservation results, etc.) that a block is available.
 *
B
Bob Peterson 已提交
1282 1283
 * Scope of @goal is just within rgrp, not the whole filesystem.
 * Scope of @returned block is just within bitmap, not the whole filesystem.
D
David Teigland 已提交
1284
 *
B
Bob Peterson 已提交
1285
 * Returns: the block number found relative to the bitmap rbi
D
David Teigland 已提交
1286 1287
 */

1288
static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
1289
			unsigned char state,
B
Bob Peterson 已提交
1290
			struct gfs2_bitmap **rbi)
D
David Teigland 已提交
1291 1292
{
	struct gfs2_bitmap *bi = NULL;
1293
	const u32 length = rgd->rd_length;
1294
	u32 blk = BFITNOENT;
D
David Teigland 已提交
1295
	unsigned int buf, x;
1296
	const u8 *buffer = NULL;
D
David Teigland 已提交
1297

B
Bob Peterson 已提交
1298
	*rbi = NULL;
D
David Teigland 已提交
1299 1300 1301
	/* Find bitmap block that contains bits for goal block */
	for (buf = 0; buf < length; buf++) {
		bi = rgd->rd_bits + buf;
1302 1303 1304 1305 1306
		/* Convert scope of "goal" from rgrp-wide to within found bit block */
		if (goal < (bi->bi_start + bi->bi_len) * GFS2_NBBY) {
			goal -= bi->bi_start * GFS2_NBBY;
			goto do_search;
		}
D
David Teigland 已提交
1307
	}
1308 1309
	buf = 0;
	goal = 0;
D
David Teigland 已提交
1310

1311
do_search:
D
David Teigland 已提交
1312 1313 1314 1315 1316 1317
	/* Search (up to entire) bitmap in this rgrp for allocatable block.
	   "x <= length", instead of "x < length", because we typically start
	   the search in the middle of a bit block, but if we can't find an
	   allocatable block anywhere else, we want to be able wrap around and
	   search in the first part of our first-searched bit block.  */
	for (x = 0; x <= length; x++) {
1318 1319 1320
		bi = rgd->rd_bits + buf;

		if (test_bit(GBF_FULL, &bi->bi_flags) &&
1321
		    (state == GFS2_BLKST_FREE))
1322 1323
			goto skip;

1324 1325
		/* The GFS2_BLKST_UNLINKED state doesn't apply to the clone
		   bitmaps, so we must search the originals for that. */
1326
		buffer = bi->bi_bh->b_data + bi->bi_offset;
1327
		WARN_ON(!buffer_uptodate(bi->bi_bh));
1328
		if (state != GFS2_BLKST_UNLINKED && bi->bi_clone)
1329 1330
			buffer = bi->bi_clone + bi->bi_offset;

1331
		blk = gfs2_bitfit(buffer, bi->bi_len, goal, state);
D
David Teigland 已提交
1332 1333 1334
		if (blk != BFITNOENT)
			break;

1335
		if ((goal == 0) && (state == GFS2_BLKST_FREE))
1336 1337
			set_bit(GBF_FULL, &bi->bi_flags);

D
David Teigland 已提交
1338
		/* Try next bitmap block (wrap back to rgrp header if at end) */
1339 1340 1341
skip:
		buf++;
		buf %= length;
D
David Teigland 已提交
1342 1343 1344
		goal = 0;
	}

B
Bob Peterson 已提交
1345 1346
	if (blk != BFITNOENT)
		*rbi = bi;
1347

B
Bob Peterson 已提交
1348 1349
	return blk;
}
1350

B
Bob Peterson 已提交
1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
/**
 * gfs2_alloc_extent - allocate an extent from a given bitmap
 * @rgd: the resource group descriptor
 * @bi: the bitmap within the rgrp
 * @blk: the block within the bitmap
 * @dinode: TRUE if the first block we allocate is for a dinode
 * @n: The extent length
 *
 * Add the found bitmap buffer to the transaction.
 * Set the found bits to @new_state to change block's allocation state.
 * Returns: starting block number of the extent (fs scope)
 */
static u64 gfs2_alloc_extent(struct gfs2_rgrpd *rgd, struct gfs2_bitmap *bi,
			     u32 blk, bool dinode, unsigned int *n)
{
	const unsigned int elen = *n;
	u32 goal;
	const u8 *buffer = NULL;

1370
	*n = 0;
B
Bob Peterson 已提交
1371
	buffer = bi->bi_bh->b_data + bi->bi_offset;
1372 1373
	gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
	gfs2_setbit(rgd, bi->bi_bh->b_data, bi->bi_clone, bi->bi_offset,
1374
		    bi, blk, dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
1375
	(*n)++;
1376 1377 1378 1379 1380 1381 1382 1383
	goal = blk;
	while (*n < elen) {
		goal++;
		if (goal >= (bi->bi_len * GFS2_NBBY))
			break;
		if (gfs2_testbit(rgd, buffer, bi->bi_len, goal) !=
		    GFS2_BLKST_FREE)
			break;
1384
		gfs2_setbit(rgd, bi->bi_bh->b_data, bi->bi_clone, bi->bi_offset,
1385
			    bi, goal, GFS2_BLKST_USED);
1386
		(*n)++;
1387
	}
B
Bob Peterson 已提交
1388
	blk = gfs2_bi2rgd_blk(bi, blk);
1389
	rgd->rd_last_alloc = blk + *n - 1;
B
Bob Peterson 已提交
1390
	return rgd->rd_data0 + blk;
D
David Teigland 已提交
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
}

/**
 * rgblk_free - Change alloc state of given block(s)
 * @sdp: the filesystem
 * @bstart: the start of a run of blocks to free
 * @blen: the length of the block run (all must lie within ONE RG!)
 * @new_state: GFS2_BLKST_XXX the after-allocation block state
 *
 * Returns:  Resource group containing the block(s)
 */

1403 1404
static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
				     u32 blen, unsigned char new_state)
D
David Teigland 已提交
1405 1406 1407
{
	struct gfs2_rgrpd *rgd;
	struct gfs2_bitmap *bi = NULL;
1408
	u32 length, rgrp_blk, buf_blk;
D
David Teigland 已提交
1409 1410
	unsigned int buf;

S
Steven Whitehouse 已提交
1411
	rgd = gfs2_blk2rgrpd(sdp, bstart, 1);
D
David Teigland 已提交
1412 1413
	if (!rgd) {
		if (gfs2_consist(sdp))
1414
			fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);
D
David Teigland 已提交
1415 1416 1417
		return NULL;
	}

1418
	length = rgd->rd_length;
D
David Teigland 已提交
1419

1420
	rgrp_blk = bstart - rgd->rd_data0;
D
David Teigland 已提交
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435

	while (blen--) {
		for (buf = 0; buf < length; buf++) {
			bi = rgd->rd_bits + buf;
			if (rgrp_blk < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
				break;
		}

		gfs2_assert(rgd->rd_sbd, buf < length);

		buf_blk = rgrp_blk - bi->bi_start * GFS2_NBBY;
		rgrp_blk++;

		if (!bi->bi_clone) {
			bi->bi_clone = kmalloc(bi->bi_bh->b_size,
1436
					       GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
1437 1438 1439 1440
			memcpy(bi->bi_clone + bi->bi_offset,
			       bi->bi_bh->b_data + bi->bi_offset,
			       bi->bi_len);
		}
1441
		gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
1442
		gfs2_setbit(rgd, bi->bi_bh->b_data, NULL, bi->bi_offset,
1443
			    bi, buf_blk, new_state);
D
David Teigland 已提交
1444 1445 1446 1447 1448 1449
	}

	return rgd;
}

/**
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
 * gfs2_rgrp_dump - print out an rgrp
 * @seq: The iterator
 * @gl: The glock in question
 *
 */

int gfs2_rgrp_dump(struct seq_file *seq, const struct gfs2_glock *gl)
{
	const struct gfs2_rgrpd *rgd = gl->gl_object;
	if (rgd == NULL)
		return 0;
	gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u\n",
		       (unsigned long long)rgd->rd_addr, rgd->rd_flags,
		       rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes);
	return 0;
}

1467 1468 1469 1470
static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	fs_warn(sdp, "rgrp %llu has an error, marking it readonly until umount\n",
S
Steven Whitehouse 已提交
1471
		(unsigned long long)rgd->rd_addr);
1472 1473 1474 1475 1476
	fs_warn(sdp, "umount on all nodes and run fsck.gfs2 to fix the error\n");
	gfs2_rgrp_dump(NULL, rgd->rd_gl);
	rgd->rd_flags |= GFS2_RDF_ERROR;
}

1477
/**
1478
 * gfs2_alloc_blocks - Allocate one or more blocks of data and/or a dinode
1479
 * @ip: the inode to allocate the block for
1480
 * @bn: Used to return the starting block number
1481
 * @ndata: requested number of blocks/extent length (value/result)
1482
 * @dinode: 1 if we're allocating a dinode block, else 0
1483
 * @generation: the generation number of the inode
D
David Teigland 已提交
1484
 *
1485
 * Returns: 0 or error
D
David Teigland 已提交
1486 1487
 */

1488
int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
1489
		      bool dinode, u64 *generation)
D
David Teigland 已提交
1490
{
1491
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1492
	struct buffer_head *dibh;
1493
	struct gfs2_rgrpd *rgd;
1494 1495
	unsigned int ndata;
	u32 goal, blk; /* block, within the rgrp scope */
1496
	u64 block; /* block, within the file system scope */
1497
	int error;
B
Bob Peterson 已提交
1498
	struct gfs2_bitmap *bi;
D
David Teigland 已提交
1499

1500 1501 1502
	/* Only happens if there is a bug in gfs2, return something distinctive
	 * to ensure that it is noticed.
	 */
1503
	if (ip->i_res == NULL)
1504 1505
		return -ECANCELED;

1506
	rgd = ip->i_rgd;
1507

1508
	if (!dinode && rgrp_contains_block(rgd, ip->i_goal))
1509
		goal = ip->i_goal - rgd->rd_data0;
D
David Teigland 已提交
1510
	else
1511
		goal = rgd->rd_last_alloc;
D
David Teigland 已提交
1512

1513
	blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, &bi);
1514 1515 1516 1517

	/* Since all blocks are reserved in advance, this shouldn't happen */
	if (blk == BFITNOENT)
		goto rgrp_error;
D
David Teigland 已提交
1518

1519 1520 1521 1522
	block = gfs2_alloc_extent(rgd, bi, blk, dinode, nblocks);
	ndata = *nblocks;
	if (dinode)
		ndata--;
B
Bob Peterson 已提交
1523

1524
	if (!dinode) {
1525
		ip->i_goal = block + ndata - 1;
1526 1527 1528 1529 1530 1531 1532 1533 1534
		error = gfs2_meta_inode_buffer(ip, &dibh);
		if (error == 0) {
			struct gfs2_dinode *di =
				(struct gfs2_dinode *)dibh->b_data;
			gfs2_trans_add_bh(ip->i_gl, dibh, 1);
			di->di_goal_meta = di->di_goal_data =
				cpu_to_be64(ip->i_goal);
			brelse(dibh);
		}
1535
	}
1536
	if (rgd->rd_free < *nblocks)
1537 1538
		goto rgrp_error;

1539
	rgd->rd_free -= *nblocks;
1540 1541 1542 1543 1544 1545
	if (dinode) {
		rgd->rd_dinodes++;
		*generation = rgd->rd_igeneration++;
		if (*generation == 0)
			*generation = rgd->rd_igeneration++;
	}
D
David Teigland 已提交
1546

1547
	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1548
	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
D
David Teigland 已提交
1549

1550
	gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
1551 1552
	if (dinode)
		gfs2_trans_add_unrevoke(sdp, block, 1);
1553 1554 1555 1556 1557 1558 1559

	/*
	 * This needs reviewing to see why we cannot do the quota change
	 * at this point in the dinode case.
	 */
	if (ndata)
		gfs2_quota_change(ip, ndata, ip->i_inode.i_uid,
1560
				  ip->i_inode.i_gid);
D
David Teigland 已提交
1561

1562 1563
	rgd->rd_free_clone -= *nblocks;
	trace_gfs2_block_alloc(ip, block, *nblocks,
1564
			       dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
1565 1566 1567 1568 1569 1570
	*bn = block;
	return 0;

rgrp_error:
	gfs2_rgrp_error(rgd);
	return -EIO;
D
David Teigland 已提交
1571 1572 1573
}

/**
1574
 * __gfs2_free_blocks - free a contiguous run of block(s)
D
David Teigland 已提交
1575 1576 1577
 * @ip: the inode these blocks are being freed from
 * @bstart: first block of a run of contiguous blocks
 * @blen: the length of the block run
1578
 * @meta: 1 if the blocks represent metadata
D
David Teigland 已提交
1579 1580 1581
 *
 */

1582
void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta)
D
David Teigland 已提交
1583
{
1584
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
1585 1586 1587 1588 1589
	struct gfs2_rgrpd *rgd;

	rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
	if (!rgd)
		return;
S
Steven Whitehouse 已提交
1590
	trace_gfs2_block_alloc(ip, bstart, blen, GFS2_BLKST_FREE);
1591
	rgd->rd_free += blen;
S
Steven Whitehouse 已提交
1592
	rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
1593
	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1594
	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
D
David Teigland 已提交
1595

1596
	/* Directories keep their data in the metadata address space */
1597
	if (meta || ip->i_depth)
1598
		gfs2_meta_wipe(ip, bstart, blen);
1599
}
D
David Teigland 已提交
1600

1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612
/**
 * gfs2_free_meta - free a contiguous run of data block(s)
 * @ip: the inode these blocks are being freed from
 * @bstart: first block of a run of contiguous blocks
 * @blen: the length of the block run
 *
 */

void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)
{
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

1613
	__gfs2_free_blocks(ip, bstart, blen, 1);
D
David Teigland 已提交
1614
	gfs2_statfs_change(sdp, 0, +blen, 0);
1615
	gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
D
David Teigland 已提交
1616 1617
}

1618 1619 1620 1621 1622
void gfs2_unlink_di(struct inode *inode)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
	struct gfs2_rgrpd *rgd;
1623
	u64 blkno = ip->i_no_addr;
1624 1625 1626 1627

	rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);
	if (!rgd)
		return;
S
Steven Whitehouse 已提交
1628
	trace_gfs2_block_alloc(ip, blkno, 1, GFS2_BLKST_UNLINKED);
1629
	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1630
	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
1631 1632
}

1633
static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
D
David Teigland 已提交
1634 1635 1636 1637 1638 1639 1640 1641 1642
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct gfs2_rgrpd *tmp_rgd;

	tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE);
	if (!tmp_rgd)
		return;
	gfs2_assert_withdraw(sdp, rgd == tmp_rgd);

1643
	if (!rgd->rd_dinodes)
D
David Teigland 已提交
1644
		gfs2_consist_rgrpd(rgd);
1645
	rgd->rd_dinodes--;
1646
	rgd->rd_free++;
D
David Teigland 已提交
1647

1648
	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1649
	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
D
David Teigland 已提交
1650 1651 1652 1653 1654 1655 1656

	gfs2_statfs_change(sdp, 0, +1, -1);
}


void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
{
1657
	gfs2_free_uninit_di(rgd, ip->i_no_addr);
S
Steven Whitehouse 已提交
1658
	trace_gfs2_block_alloc(ip, ip->i_no_addr, 1, GFS2_BLKST_FREE);
1659
	gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
1660
	gfs2_meta_wipe(ip, ip->i_no_addr, 1);
D
David Teigland 已提交
1661 1662
}

1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676
/**
 * gfs2_check_blk_type - Check the type of a block
 * @sdp: The superblock
 * @no_addr: The block number to check
 * @type: The block type we are looking for
 *
 * Returns: 0 if the block type matches the expected type
 *          -ESTALE if it doesn't match
 *          or -ve errno if something went wrong while checking
 */

int gfs2_check_blk_type(struct gfs2_sbd *sdp, u64 no_addr, unsigned int type)
{
	struct gfs2_rgrpd *rgd;
1677
	struct gfs2_holder rgd_gh;
1678
	int error = -EINVAL;
1679

S
Steven Whitehouse 已提交
1680
	rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
1681
	if (!rgd)
1682
		goto fail;
1683 1684 1685

	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
	if (error)
1686
		goto fail;
1687 1688 1689 1690 1691 1692 1693 1694 1695

	if (gfs2_get_block_type(rgd, no_addr) != type)
		error = -ESTALE;

	gfs2_glock_dq_uninit(&rgd_gh);
fail:
	return error;
}

D
David Teigland 已提交
1696 1697
/**
 * gfs2_rlist_add - add a RG to a list of RGs
1698
 * @ip: the inode
D
David Teigland 已提交
1699 1700 1701 1702 1703 1704 1705 1706 1707
 * @rlist: the list of resource groups
 * @block: the block
 *
 * Figure out what RG a block belongs to and add that RG to the list
 *
 * FIXME: Don't use NOFAIL
 *
 */

1708
void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
1709
		    u64 block)
D
David Teigland 已提交
1710
{
1711
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
1712 1713 1714 1715 1716 1717 1718 1719
	struct gfs2_rgrpd *rgd;
	struct gfs2_rgrpd **tmp;
	unsigned int new_space;
	unsigned int x;

	if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
		return;

1720 1721 1722
	if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, block))
		rgd = ip->i_rgd;
	else
S
Steven Whitehouse 已提交
1723
		rgd = gfs2_blk2rgrpd(sdp, block, 1);
D
David Teigland 已提交
1724
	if (!rgd) {
1725
		fs_err(sdp, "rlist_add: no rgrp for block %llu\n", (unsigned long long)block);
D
David Teigland 已提交
1726 1727
		return;
	}
1728
	ip->i_rgd = rgd;
D
David Teigland 已提交
1729 1730 1731 1732 1733 1734 1735 1736 1737

	for (x = 0; x < rlist->rl_rgrps; x++)
		if (rlist->rl_rgd[x] == rgd)
			return;

	if (rlist->rl_rgrps == rlist->rl_space) {
		new_space = rlist->rl_space + 10;

		tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
1738
			      GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763

		if (rlist->rl_rgd) {
			memcpy(tmp, rlist->rl_rgd,
			       rlist->rl_space * sizeof(struct gfs2_rgrpd *));
			kfree(rlist->rl_rgd);
		}

		rlist->rl_space = new_space;
		rlist->rl_rgd = tmp;
	}

	rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
}

/**
 * gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
 *      and initialize an array of glock holders for them
 * @rlist: the list of resource groups
 * @state: the lock state to acquire the RG lock in
 * @flags: the modifier flags for the holder structures
 *
 * FIXME: Don't use NOFAIL
 *
 */

1764
void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state)
D
David Teigland 已提交
1765 1766 1767 1768
{
	unsigned int x;

	rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder),
1769
				GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
1770 1771
	for (x = 0; x < rlist->rl_rgrps; x++)
		gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
1772
				state, 0,
D
David Teigland 已提交
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
				&rlist->rl_ghs[x]);
}

/**
 * gfs2_rlist_free - free a resource group list
 * @list: the list of resource groups
 *
 */

void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
{
	unsigned int x;

	kfree(rlist->rl_rgd);

	if (rlist->rl_ghs) {
		for (x = 0; x < rlist->rl_rgrps; x++)
			gfs2_holder_uninit(&rlist->rl_ghs[x]);
		kfree(rlist->rl_ghs);
	}
}