rgrp.c 64.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>
S
Steven Whitehouse 已提交
19
#include <linux/random.h>
D
David Teigland 已提交
20 21

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

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

39 40 41 42 43 44 45 46 47 48
#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

49 50 51
/*
 * These routines are used by the resource group routines (rgrp.c)
 * to keep track of block allocation.  Each block is represented by two
52 53 54 55 56 57
 * 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)
58 59
 */

60 61 62 63 64
struct gfs2_extent {
	struct gfs2_rbm rbm;
	u32 len;
};

65 66
static const char valid_change[16] = {
	        /* current */
67
	/* n */ 0, 1, 1, 1,
68
	/* e */ 1, 0, 0, 0,
69
	/* w */ 0, 0, 0, 1,
70 71 72
	        1, 0, 0, 0
};

73 74 75
static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 *minext,
			 const struct gfs2_inode *ip, bool nowrap,
			 const struct gfs2_alloc_parms *ap);
76 77


78 79
/**
 * gfs2_setbit - Set a bit in the bitmaps
80 81
 * @rbm: The position of the bit to set
 * @do_clone: Also set the clone bitmap, if it exists
82 83 84 85
 * @new_state: the new state of the block
 *
 */

86
static inline void gfs2_setbit(const struct gfs2_rbm *rbm, bool do_clone,
87
			       unsigned char new_state)
88
{
89
	unsigned char *byte1, *byte2, *end, cur_state;
B
Bob Peterson 已提交
90 91
	struct gfs2_bitmap *bi = rbm_bi(rbm);
	unsigned int buflen = bi->bi_len;
92
	const unsigned int bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
93

B
Bob Peterson 已提交
94 95
	byte1 = bi->bi_bh->b_data + bi->bi_offset + (rbm->offset / GFS2_NBBY);
	end = bi->bi_bh->b_data + bi->bi_offset + buflen;
96

97
	BUG_ON(byte1 >= end);
98

99
	cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
100

101
	if (unlikely(!valid_change[new_state * 4 + cur_state])) {
102 103 104
		printk(KERN_WARNING "GFS2: buf_blk = 0x%x old_state=%d, "
		       "new_state=%d\n", rbm->offset, cur_state, new_state);
		printk(KERN_WARNING "GFS2: rgrp=0x%llx bi_start=0x%x\n",
B
Bob Peterson 已提交
105
		       (unsigned long long)rbm->rgd->rd_addr, bi->bi_start);
106
		printk(KERN_WARNING "GFS2: bi_offset=0x%x bi_len=0x%x\n",
B
Bob Peterson 已提交
107
		       bi->bi_offset, bi->bi_len);
108
		dump_stack();
109
		gfs2_consist_rgrpd(rbm->rgd);
110 111 112 113
		return;
	}
	*byte1 ^= (cur_state ^ new_state) << bit;

B
Bob Peterson 已提交
114 115
	if (do_clone && bi->bi_clone) {
		byte2 = bi->bi_clone + bi->bi_offset + (rbm->offset / GFS2_NBBY);
116 117 118
		cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
		*byte2 ^= (cur_state ^ new_state) << bit;
	}
119 120 121 122
}

/**
 * gfs2_testbit - test a bit in the bitmaps
123
 * @rbm: The bit to test
124
 *
125
 * Returns: The two bit block state of the requested bit
126 127
 */

128
static inline u8 gfs2_testbit(const struct gfs2_rbm *rbm)
129
{
B
Bob Peterson 已提交
130 131
	struct gfs2_bitmap *bi = rbm_bi(rbm);
	const u8 *buffer = bi->bi_bh->b_data + bi->bi_offset;
132
	const u8 *byte;
133 134
	unsigned int bit;

135 136
	byte = buffer + (rbm->offset / GFS2_NBBY);
	bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
137

138
	return (*byte >> bit) & GFS2_BIT_MASK;
139 140
}

141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
/**
 * 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[] = {
163 164 165 166
		[0] = 0xffffffffffffffffULL,
		[1] = 0xaaaaaaaaaaaaaaaaULL,
		[2] = 0x5555555555555555ULL,
		[3] = 0x0000000000000000ULL,
167 168 169 170 171 172 173
	};
	tmp = le64_to_cpu(*ptr) ^ search[state];
	tmp &= (tmp >> 1);
	tmp &= mask;
	return tmp;
}

B
Bob Peterson 已提交
174 175 176 177 178 179 180 181 182 183 184 185
/**
 * rs_cmp - multi-block reservation range compare
 * @blk: absolute file system block number of the new reservation
 * @len: number of blocks in the new reservation
 * @rs: existing reservation to compare against
 *
 * returns: 1 if the block range is beyond the reach of the reservation
 *         -1 if the block range is before the start of the reservation
 *          0 if the block range overlaps with the reservation
 */
static inline int rs_cmp(u64 blk, u32 len, struct gfs2_blkreserv *rs)
{
186
	u64 startblk = gfs2_rbm_to_block(&rs->rs_rbm);
B
Bob Peterson 已提交
187 188 189 190 191 192 193 194

	if (blk >= startblk + rs->rs_free)
		return 1;
	if (blk + len - 1 < startblk)
		return -1;
	return 0;
}

195 196 197
/**
 * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
 *       a block in a given allocation state.
198
 * @buf: the buffer that holds the bitmaps
199
 * @len: the length (in bytes) of the buffer
200
 * @goal: start search at this block's bit-pair (within @buffer)
201
 * @state: GFS2_BLKST_XXX the state of the block we're looking for.
202 203 204
 *
 * 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
205 206 207 208 209
 * 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
210
 * always ok to read a complete multiple of 64 bits at the end
211
 * of the block in case the end is no aligned to a natural boundary.
212 213 214 215
 *
 * Return: the block number (bitmap buffer scope) that was found
 */

216 217
static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
		       u32 goal, u8 state)
218
{
219 220 221 222
	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;
223
	u64 mask = 0x5555555555555555ULL;
224 225 226 227 228 229 230
	u32 bit;

	/* 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) {
231
		tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
232
		ptr++;
233
	}
234 235 236 237 238 239 240
	/* 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--;
241
	bit = __ffs64(tmp);
242 243
	bit /= 2;	/* two bits per entry in the bitmap */
	return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
244 245
}

246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
/**
 * gfs2_rbm_from_block - Set the rbm based upon rgd and block number
 * @rbm: The rbm with rgd already set correctly
 * @block: The block number (filesystem relative)
 *
 * This sets the bi and offset members of an rbm based on a
 * resource group and a filesystem relative block number. The
 * resource group must be set in the rbm on entry, the bi and
 * offset members will be set by this function.
 *
 * Returns: 0 on success, or an error code
 */

static int gfs2_rbm_from_block(struct gfs2_rbm *rbm, u64 block)
{
	u64 rblock = block - rbm->rgd->rd_data0;

	if (WARN_ON_ONCE(rblock > UINT_MAX))
		return -EINVAL;
	if (block >= rbm->rgd->rd_data0 + rbm->rgd->rd_data)
		return -E2BIG;

B
Bob Peterson 已提交
268
	rbm->bii = 0;
B
Bob Peterson 已提交
269 270
	rbm->offset = (u32)(rblock);
	/* Check if the block is within the first block */
B
Bob Peterson 已提交
271
	if (rbm->offset < rbm_bi(rbm)->bi_blocks)
B
Bob Peterson 已提交
272 273 274 275 276
		return 0;

	/* Adjust for the size diff between gfs2_meta_header and gfs2_rgrp */
	rbm->offset += (sizeof(struct gfs2_rgrp) -
			sizeof(struct gfs2_meta_header)) * GFS2_NBBY;
B
Bob Peterson 已提交
277 278
	rbm->bii = rbm->offset / rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
	rbm->offset -= rbm->bii * rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
279 280 281
	return 0;
}

B
Bob Peterson 已提交
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
/**
 * gfs2_rbm_incr - increment an rbm structure
 * @rbm: The rbm with rgd already set correctly
 *
 * This function takes an existing rbm structure and increments it to the next
 * viable block offset.
 *
 * Returns: If incrementing the offset would cause the rbm to go past the
 *          end of the rgrp, true is returned, otherwise false.
 *
 */

static bool gfs2_rbm_incr(struct gfs2_rbm *rbm)
{
	if (rbm->offset + 1 < rbm_bi(rbm)->bi_blocks) { /* in the same bitmap */
		rbm->offset++;
		return false;
	}
	if (rbm->bii == rbm->rgd->rd_length - 1) /* at the last bitmap */
		return true;

	rbm->offset = 0;
	rbm->bii++;
	return false;
}

308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
/**
 * gfs2_unaligned_extlen - Look for free blocks which are not byte aligned
 * @rbm: Position to search (value/result)
 * @n_unaligned: Number of unaligned blocks to check
 * @len: Decremented for each block found (terminate on zero)
 *
 * Returns: true if a non-free block is encountered
 */

static bool gfs2_unaligned_extlen(struct gfs2_rbm *rbm, u32 n_unaligned, u32 *len)
{
	u32 n;
	u8 res;

	for (n = 0; n < n_unaligned; n++) {
		res = gfs2_testbit(rbm);
		if (res != GFS2_BLKST_FREE)
			return true;
		(*len)--;
		if (*len == 0)
			return true;
B
Bob Peterson 已提交
329
		if (gfs2_rbm_incr(rbm))
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
			return true;
	}

	return false;
}

/**
 * gfs2_free_extlen - Return extent length of free blocks
 * @rbm: Starting position
 * @len: Max length to check
 *
 * Starting at the block specified by the rbm, see how many free blocks
 * there are, not reading more than len blocks ahead. This can be done
 * using memchr_inv when the blocks are byte aligned, but has to be done
 * on a block by block basis in case of unaligned blocks. Also this
 * function can cope with bitmap boundaries (although it must stop on
 * a resource group boundary)
 *
 * Returns: Number of free blocks in the extent
 */

static u32 gfs2_free_extlen(const struct gfs2_rbm *rrbm, u32 len)
{
	struct gfs2_rbm rbm = *rrbm;
	u32 n_unaligned = rbm.offset & 3;
	u32 size = len;
	u32 bytes;
	u32 chunk_size;
	u8 *ptr, *start, *end;
	u64 block;
B
Bob Peterson 已提交
360
	struct gfs2_bitmap *bi;
361 362 363 364 365

	if (n_unaligned &&
	    gfs2_unaligned_extlen(&rbm, 4 - n_unaligned, &len))
		goto out;

366
	n_unaligned = len & 3;
367 368
	/* Start is now byte aligned */
	while (len > 3) {
B
Bob Peterson 已提交
369 370 371 372 373 374
		bi = rbm_bi(&rbm);
		start = bi->bi_bh->b_data;
		if (bi->bi_clone)
			start = bi->bi_clone;
		end = start + bi->bi_bh->b_size;
		start += bi->bi_offset;
375 376 377 378 379 380 381 382 383
		BUG_ON(rbm.offset & 3);
		start += (rbm.offset / GFS2_NBBY);
		bytes = min_t(u32, len / GFS2_NBBY, (end - start));
		ptr = memchr_inv(start, 0, bytes);
		chunk_size = ((ptr == NULL) ? bytes : (ptr - start));
		chunk_size *= GFS2_NBBY;
		BUG_ON(len < chunk_size);
		len -= chunk_size;
		block = gfs2_rbm_to_block(&rbm);
384 385
		if (gfs2_rbm_from_block(&rbm, block + chunk_size)) {
			n_unaligned = 0;
386
			break;
387 388 389 390 391
		}
		if (ptr) {
			n_unaligned = 3;
			break;
		}
392 393 394 395 396 397 398 399 400 401
		n_unaligned = len & 3;
	}

	/* Deal with any bits left over at the end */
	if (n_unaligned)
		gfs2_unaligned_extlen(&rbm, n_unaligned, &len);
out:
	return size - len;
}

402 403
/**
 * gfs2_bitcount - count the number of bits in a certain state
404
 * @rgd: the resource group descriptor
405 406 407 408 409 410 411
 * @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
 */

412 413
static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
			 unsigned int buflen, u8 state)
414
{
415 416 417 418 419
	const u8 *byte = buffer;
	const u8 *end = buffer + buflen;
	const u8 state1 = state << 2;
	const u8 state2 = state << 4;
	const u8 state3 = state << 6;
420
	u32 count = 0;
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435

	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 已提交
436 437 438 439 440 441 442 443 444 445
/**
 * gfs2_rgrp_verify - Verify that a resource group is consistent
 * @rgd: the rgrp
 *
 */

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

450
	memset(count, 0, 4 * sizeof(u32));
D
David Teigland 已提交
451 452 453 454 455 456 457 458 459 460 461

	/* 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);
	}

462
	if (count[0] != rgd->rd_free) {
D
David Teigland 已提交
463 464
		if (gfs2_consist_rgrpd(rgd))
			fs_err(sdp, "free data mismatch:  %u != %u\n",
465
			       count[0], rgd->rd_free);
D
David Teigland 已提交
466 467 468
		return;
	}

469
	tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
470
	if (count[1] != tmp) {
D
David Teigland 已提交
471 472 473 474 475 476
		if (gfs2_consist_rgrpd(rgd))
			fs_err(sdp, "used data mismatch:  %u != %u\n",
			       count[1], tmp);
		return;
	}

477
	if (count[2] + count[3] != rgd->rd_dinodes) {
D
David Teigland 已提交
478
		if (gfs2_consist_rgrpd(rgd))
479
			fs_err(sdp, "used metadata mismatch:  %u != %u\n",
480
			       count[2] + count[3], rgd->rd_dinodes);
D
David Teigland 已提交
481 482 483 484
		return;
	}
}

485
static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block)
D
David Teigland 已提交
486
{
487 488
	u64 first = rgd->rd_data0;
	u64 last = first + rgd->rd_data;
489
	return first <= block && block < last;
D
David Teigland 已提交
490 491 492 493 494
}

/**
 * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
 * @sdp: The GFS2 superblock
495 496
 * @blk: The data block number
 * @exact: True if this needs to be an exact match
D
David Teigland 已提交
497 498 499 500
 *
 * Returns: The resource group, or NULL if not found
 */

S
Steven Whitehouse 已提交
501
struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
D
David Teigland 已提交
502
{
S
Steven Whitehouse 已提交
503
	struct rb_node *n, *next;
504
	struct gfs2_rgrpd *cur;
D
David Teigland 已提交
505 506

	spin_lock(&sdp->sd_rindex_spin);
S
Steven Whitehouse 已提交
507 508 509 510
	n = sdp->sd_rindex_tree.rb_node;
	while (n) {
		cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
		next = NULL;
511
		if (blk < cur->rd_addr)
S
Steven Whitehouse 已提交
512
			next = n->rb_left;
513
		else if (blk >= cur->rd_data0 + cur->rd_data)
S
Steven Whitehouse 已提交
514 515
			next = n->rb_right;
		if (next == NULL) {
D
David Teigland 已提交
516
			spin_unlock(&sdp->sd_rindex_spin);
S
Steven Whitehouse 已提交
517 518 519 520 521 522
			if (exact) {
				if (blk < cur->rd_addr)
					return NULL;
				if (blk >= cur->rd_data0 + cur->rd_data)
					return NULL;
			}
523
			return cur;
D
David Teigland 已提交
524
		}
S
Steven Whitehouse 已提交
525
		n = next;
D
David Teigland 已提交
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
	}
	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)
{
541 542 543
	const struct rb_node *n;
	struct gfs2_rgrpd *rgd;

544
	spin_lock(&sdp->sd_rindex_spin);
545 546
	n = rb_first(&sdp->sd_rindex_tree);
	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
547
	spin_unlock(&sdp->sd_rindex_spin);
548 549

	return rgd;
D
David Teigland 已提交
550 551 552 553
}

/**
 * gfs2_rgrpd_get_next - get the next RG
554
 * @rgd: the resource group descriptor
D
David Teigland 已提交
555 556 557 558 559 560
 *
 * Returns: The next rgrp
 */

struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
{
561 562 563 564 565 566 567 568 569 570
	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 已提交
571
		return NULL;
572 573 574 575
	}
	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
	spin_unlock(&sdp->sd_rindex_spin);
	return rgd;
D
David Teigland 已提交
576 577
}

578 579 580 581 582 583 584 585 586 587 588
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;
	}
}

589 590 591 592 593 594
/**
 * gfs2_rs_alloc - make sure we have a reservation assigned to the inode
 * @ip: the inode for this reservation
 */
int gfs2_rs_alloc(struct gfs2_inode *ip)
{
A
Abhijith Das 已提交
595
	int error = 0;
B
Bob Peterson 已提交
596

A
Abhijith Das 已提交
597
	down_write(&ip->i_rw_mutex);
B
Bob Peterson 已提交
598
	if (ip->i_res)
A
Abhijith Das 已提交
599
		goto out;
600

A
Abhijith Das 已提交
601 602 603 604 605
	ip->i_res = kmem_cache_zalloc(gfs2_rsrv_cachep, GFP_NOFS);
	if (!ip->i_res) {
		error = -ENOMEM;
		goto out;
	}
606

A
Abhijith Das 已提交
607 608
	RB_CLEAR_NODE(&ip->i_res->rs_node);
out:
609
	up_write(&ip->i_rw_mutex);
610
	return error;
611 612
}

613
static void dump_rs(struct seq_file *seq, const struct gfs2_blkreserv *rs)
B
Bob Peterson 已提交
614
{
615 616 617
	gfs2_print_dbg(seq, "  B: n:%llu s:%llu b:%u f:%u\n",
		       (unsigned long long)rs->rs_inum,
		       (unsigned long long)gfs2_rbm_to_block(&rs->rs_rbm),
618
		       rs->rs_rbm.offset, rs->rs_free);
B
Bob Peterson 已提交
619 620
}

621
/**
B
Bob Peterson 已提交
622 623 624 625
 * __rs_deltree - remove a multi-block reservation from the rgd tree
 * @rs: The reservation to remove
 *
 */
626
static void __rs_deltree(struct gfs2_blkreserv *rs)
B
Bob Peterson 已提交
627 628 629 630 631 632
{
	struct gfs2_rgrpd *rgd;

	if (!gfs2_rs_active(rs))
		return;

633
	rgd = rs->rs_rbm.rgd;
634
	trace_gfs2_rs(rs, TRACE_RS_TREEDEL);
635
	rb_erase(&rs->rs_node, &rgd->rd_rstree);
636
	RB_CLEAR_NODE(&rs->rs_node);
B
Bob Peterson 已提交
637 638

	if (rs->rs_free) {
B
Bob Peterson 已提交
639 640
		struct gfs2_bitmap *bi = rbm_bi(&rs->rs_rbm);

641
		/* return reserved blocks to the rgrp */
642 643
		BUG_ON(rs->rs_rbm.rgd->rd_reserved < rs->rs_free);
		rs->rs_rbm.rgd->rd_reserved -= rs->rs_free;
B
Bob Peterson 已提交
644
		rs->rs_free = 0;
B
Bob Peterson 已提交
645
		clear_bit(GBF_FULL, &bi->bi_flags);
B
Bob Peterson 已提交
646 647 648 649 650 651 652 653 654
		smp_mb__after_clear_bit();
	}
}

/**
 * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
 * @rs: The reservation to remove
 *
 */
655
void gfs2_rs_deltree(struct gfs2_blkreserv *rs)
B
Bob Peterson 已提交
656 657 658
{
	struct gfs2_rgrpd *rgd;

659 660 661
	rgd = rs->rs_rbm.rgd;
	if (rgd) {
		spin_lock(&rgd->rd_rsspin);
662
		__rs_deltree(rs);
663 664
		spin_unlock(&rgd->rd_rsspin);
	}
B
Bob Peterson 已提交
665 666 667 668
}

/**
 * gfs2_rs_delete - delete a multi-block reservation
669
 * @ip: The inode for this reservation
670
 * @wcount: The inode's write count, or NULL
671 672
 *
 */
673
void gfs2_rs_delete(struct gfs2_inode *ip, atomic_t *wcount)
674 675
{
	down_write(&ip->i_rw_mutex);
676
	if (ip->i_res && ((wcount == NULL) || (atomic_read(wcount) <= 1))) {
677
		gfs2_rs_deltree(ip->i_res);
B
Bob Peterson 已提交
678
		BUG_ON(ip->i_res->rs_free);
679 680 681 682 683 684
		kmem_cache_free(gfs2_rsrv_cachep, ip->i_res);
		ip->i_res = NULL;
	}
	up_write(&ip->i_rw_mutex);
}

B
Bob Peterson 已提交
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
/**
 * return_all_reservations - return all reserved blocks back to the rgrp.
 * @rgd: the rgrp that needs its space back
 *
 * We previously reserved a bunch of blocks for allocation. Now we need to
 * give them back. This leave the reservation structures in tact, but removes
 * all of their corresponding "no-fly zones".
 */
static void return_all_reservations(struct gfs2_rgrpd *rgd)
{
	struct rb_node *n;
	struct gfs2_blkreserv *rs;

	spin_lock(&rgd->rd_rsspin);
	while ((n = rb_first(&rgd->rd_rstree))) {
		rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
701
		__rs_deltree(rs);
B
Bob Peterson 已提交
702 703 704 705
	}
	spin_unlock(&rgd->rd_rsspin);
}

706
void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
D
David Teigland 已提交
707
{
708
	struct rb_node *n;
D
David Teigland 已提交
709 710 711
	struct gfs2_rgrpd *rgd;
	struct gfs2_glock *gl;

712 713
	while ((n = rb_first(&sdp->sd_rindex_tree))) {
		rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
D
David Teigland 已提交
714 715
		gl = rgd->rd_gl;

716
		rb_erase(n, &sdp->sd_rindex_tree);
D
David Teigland 已提交
717 718

		if (gl) {
719
			spin_lock(&gl->gl_spin);
720
			gl->gl_object = NULL;
721
			spin_unlock(&gl->gl_spin);
722
			gfs2_glock_add_to_lru(gl);
D
David Teigland 已提交
723 724 725
			gfs2_glock_put(gl);
		}

726
		gfs2_free_clones(rgd);
D
David Teigland 已提交
727
		kfree(rgd->rd_bits);
B
Bob Peterson 已提交
728
		return_all_reservations(rgd);
729
		kmem_cache_free(gfs2_rgrpd_cachep, rgd);
D
David Teigland 已提交
730 731 732
	}
}

733 734 735 736 737 738 739 740 741
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 已提交
742 743 744 745 746 747 748 749 750 751 752 753 754
/**
 * 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;
755
	u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
756
	u32 bytes_left, bytes;
D
David Teigland 已提交
757 758
	int x;

759 760 761
	if (!length)
		return -EINVAL;

762
	rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
D
David Teigland 已提交
763 764 765
	if (!rgd->rd_bits)
		return -ENOMEM;

766
	bytes_left = rgd->rd_bitbytes;
D
David Teigland 已提交
767 768 769 770

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

771
		bi->bi_flags = 0;
D
David Teigland 已提交
772 773 774 775 776 777
		/* 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;
778
			bi->bi_blocks = bytes * GFS2_NBBY;
D
David Teigland 已提交
779 780 781 782 783 784
		/* 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;
785
			bi->bi_blocks = bytes * GFS2_NBBY;
D
David Teigland 已提交
786 787 788 789
		/* last block */
		} else if (x + 1 == length) {
			bytes = bytes_left;
			bi->bi_offset = sizeof(struct gfs2_meta_header);
790
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
D
David Teigland 已提交
791
			bi->bi_len = bytes;
792
			bi->bi_blocks = bytes * GFS2_NBBY;
D
David Teigland 已提交
793 794
		/* other blocks */
		} else {
795 796
			bytes = sdp->sd_sb.sb_bsize -
				sizeof(struct gfs2_meta_header);
D
David Teigland 已提交
797
			bi->bi_offset = sizeof(struct gfs2_meta_header);
798
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
D
David Teigland 已提交
799
			bi->bi_len = bytes;
800
			bi->bi_blocks = bytes * GFS2_NBBY;
D
David Teigland 已提交
801 802 803 804 805 806 807 808 809 810
		}

		bytes_left -= bytes;
	}

	if (bytes_left) {
		gfs2_consist_rgrpd(rgd);
		return -EIO;
	}
	bi = rgd->rd_bits + (length - 1);
811
	if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
D
David Teigland 已提交
812
		if (gfs2_consist_rgrpd(rgd)) {
813
			gfs2_rindex_print(rgd);
D
David Teigland 已提交
814 815 816 817 818 819 820 821 822
			fs_err(sdp, "start=%u len=%u offset=%u\n",
			       bi->bi_start, bi->bi_len, bi->bi_offset);
		}
		return -EIO;
	}

	return 0;
}

823 824
/**
 * gfs2_ri_total - Total up the file system space, according to the rindex.
825
 * @sdp: the filesystem
826 827 828 829 830 831 832 833 834 835 836 837 838
 *
 */
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)];
	int error, rgrps;

	for (rgrps = 0;; rgrps++) {
		loff_t pos = rgrps * sizeof(struct gfs2_rindex);

839
		if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
840
			break;
841
		error = gfs2_internal_read(ip, buf, &pos,
842 843 844
					   sizeof(struct gfs2_rindex));
		if (error != sizeof(struct gfs2_rindex))
			break;
845
		total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
846 847 848 849
	}
	return total_data;
}

B
Bob Peterson 已提交
850
static int rgd_insert(struct gfs2_rgrpd *rgd)
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
{
	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 已提交
866
			return -EEXIST;
867 868 869 870
	}

	rb_link_node(&rgd->rd_node, parent, newn);
	rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
B
Bob Peterson 已提交
871 872
	sdp->sd_rgrps++;
	return 0;
873 874
}

D
David Teigland 已提交
875
/**
876
 * read_rindex_entry - Pull in a new resource index entry from the disk
877
 * @ip: Pointer to the rindex inode
D
David Teigland 已提交
878
 *
879
 * Returns: 0 on success, > 0 on EOF, error code otherwise
880 881
 */

882
static int read_rindex_entry(struct gfs2_inode *ip)
883 884 885
{
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
886
	struct gfs2_rindex buf;
887 888 889
	int error;
	struct gfs2_rgrpd *rgd;

890 891 892
	if (pos >= i_size_read(&ip->i_inode))
		return 1;

893
	error = gfs2_internal_read(ip, (char *)&buf, &pos,
894
				   sizeof(struct gfs2_rindex));
895 896 897

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

899
	rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
900 901 902 903 904
	error = -ENOMEM;
	if (!rgd)
		return error;

	rgd->rd_sbd = sdp;
905 906 907 908 909
	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);
B
Bob Peterson 已提交
910
	spin_lock_init(&rgd->rd_rsspin);
911

912 913
	error = compute_bitstructs(rgd);
	if (error)
914
		goto fail;
915

916
	error = gfs2_glock_get(sdp, rgd->rd_addr,
917 918
			       &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
	if (error)
919
		goto fail;
920 921

	rgd->rd_gl->gl_object = rgd;
922
	rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lksb.sb_lvbptr;
923
	rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
924 925
	if (rgd->rd_data > sdp->sd_max_rg_data)
		sdp->sd_max_rg_data = rgd->rd_data;
926
	spin_lock(&sdp->sd_rindex_spin);
B
Bob Peterson 已提交
927
	error = rgd_insert(rgd);
928
	spin_unlock(&sdp->sd_rindex_spin);
B
Bob Peterson 已提交
929 930 931 932
	if (!error)
		return 0;

	error = 0; /* someone else read in the rgrp; free it and ignore it */
933
	gfs2_glock_put(rgd->rd_gl);
934 935 936 937

fail:
	kfree(rgd->rd_bits);
	kmem_cache_free(gfs2_rgrpd_cachep, rgd);
938 939 940 941 942 943 944
	return error;
}

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

948
static int gfs2_ri_update(struct gfs2_inode *ip)
D
David Teigland 已提交
949
{
950
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
951 952
	int error;

953
	do {
954
		error = read_rindex_entry(ip);
955 956 957 958
	} while (error == 0);

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

960
	sdp->sd_rindex_uptodate = 1;
961 962
	return 0;
}
D
David Teigland 已提交
963 964

/**
965
 * gfs2_rindex_update - Update the rindex if required
D
David Teigland 已提交
966 967 968 969 970 971 972 973 974 975 976 977
 * @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.
 *
978
 * Returns: 0 on succeess, error code otherwise
D
David Teigland 已提交
979 980
 */

981
int gfs2_rindex_update(struct gfs2_sbd *sdp)
D
David Teigland 已提交
982
{
983
	struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
D
David Teigland 已提交
984
	struct gfs2_glock *gl = ip->i_gl;
985 986
	struct gfs2_holder ri_gh;
	int error = 0;
987
	int unlock_required = 0;
D
David Teigland 已提交
988 989

	/* Read new copy from disk if we don't have the latest */
990
	if (!sdp->sd_rindex_uptodate) {
991 992 993
		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 已提交
994
				return error;
995 996
			unlock_required = 1;
		}
997
		if (!sdp->sd_rindex_uptodate)
D
David Teigland 已提交
998
			error = gfs2_ri_update(ip);
999 1000
		if (unlock_required)
			gfs2_glock_dq_uninit(&ri_gh);
D
David Teigland 已提交
1001 1002 1003 1004 1005
	}

	return error;
}

1006
static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
1007 1008
{
	const struct gfs2_rgrp *str = buf;
1009
	u32 rg_flags;
1010

1011
	rg_flags = be32_to_cpu(str->rg_flags);
1012
	rg_flags &= ~GFS2_RDF_MASK;
1013 1014
	rgd->rd_flags &= GFS2_RDF_MASK;
	rgd->rd_flags |= rg_flags;
1015
	rgd->rd_free = be32_to_cpu(str->rg_free);
1016
	rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
1017
	rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
1018 1019
}

1020
static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
1021 1022 1023
{
	struct gfs2_rgrp *str = buf;

1024
	str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
1025
	str->rg_free = cpu_to_be32(rgd->rd_free);
1026
	str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
1027
	str->__pad = cpu_to_be32(0);
1028
	str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
1029 1030 1031
	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
}

1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
{
	struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
	struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;

	if (rgl->rl_flags != str->rg_flags || rgl->rl_free != str->rg_free ||
	    rgl->rl_dinodes != str->rg_dinodes ||
	    rgl->rl_igeneration != str->rg_igeneration)
		return 0;
	return 1;
}

static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb *rgl, const void *buf)
{
	const struct gfs2_rgrp *str = buf;

	rgl->rl_magic = cpu_to_be32(GFS2_MAGIC);
	rgl->rl_flags = str->rg_flags;
	rgl->rl_free = str->rg_free;
	rgl->rl_dinodes = str->rg_dinodes;
	rgl->rl_igeneration = str->rg_igeneration;
	rgl->__pad = 0UL;
}

static void update_rgrp_lvb_unlinked(struct gfs2_rgrpd *rgd, u32 change)
{
	struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
	u32 unlinked = be32_to_cpu(rgl->rl_unlinked) + change;
	rgl->rl_unlinked = cpu_to_be32(unlinked);
}

static u32 count_unlinked(struct gfs2_rgrpd *rgd)
{
	struct gfs2_bitmap *bi;
	const u32 length = rgd->rd_length;
	const u8 *buffer = NULL;
	u32 i, goal, count = 0;

	for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
		goal = 0;
		buffer = bi->bi_bh->b_data + bi->bi_offset;
		WARN_ON(!buffer_uptodate(bi->bi_bh));
		while (goal < bi->bi_len * GFS2_NBBY) {
			goal = gfs2_bitfit(buffer, bi->bi_len, goal,
					   GFS2_BLKST_UNLINKED);
			if (goal == BFITNOENT)
				break;
			count++;
			goal++;
		}
	}

	return count;
}


D
David Teigland 已提交
1088
/**
1089 1090
 * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
 * @rgd: the struct gfs2_rgrpd describing the RG to read in
D
David Teigland 已提交
1091 1092 1093 1094 1095 1096 1097
 *
 * 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
 */

1098
int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
D
David Teigland 已提交
1099 1100 1101
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct gfs2_glock *gl = rgd->rd_gl;
1102
	unsigned int length = rgd->rd_length;
D
David Teigland 已提交
1103 1104 1105 1106
	struct gfs2_bitmap *bi;
	unsigned int x, y;
	int error;

1107 1108 1109
	if (rgd->rd_bits[0].bi_bh != NULL)
		return 0;

D
David Teigland 已提交
1110 1111
	for (x = 0; x < length; x++) {
		bi = rgd->rd_bits + x;
1112
		error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
D
David Teigland 已提交
1113 1114 1115 1116 1117 1118
		if (error)
			goto fail;
	}

	for (y = length; y--;) {
		bi = rgd->rd_bits + y;
S
Steven Whitehouse 已提交
1119
		error = gfs2_meta_wait(sdp, bi->bi_bh);
D
David Teigland 已提交
1120 1121
		if (error)
			goto fail;
1122
		if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
D
David Teigland 已提交
1123 1124 1125 1126 1127 1128
					      GFS2_METATYPE_RG)) {
			error = -EIO;
			goto fail;
		}
	}

1129
	if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
1130 1131
		for (x = 0; x < length; x++)
			clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
1132
		gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
1133
		rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
1134
		rgd->rd_free_clone = rgd->rd_free;
D
David Teigland 已提交
1135
	}
A
Al Viro 已提交
1136
	if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
		rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
		gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
				     rgd->rd_bits[0].bi_bh->b_data);
	}
	else if (sdp->sd_args.ar_rgrplvb) {
		if (!gfs2_rgrp_lvb_valid(rgd)){
			gfs2_consist_rgrpd(rgd);
			error = -EIO;
			goto fail;
		}
		if (rgd->rd_rgl->rl_unlinked == 0)
			rgd->rd_flags &= ~GFS2_RDF_CHECK;
	}
D
David Teigland 已提交
1150 1151
	return 0;

1152
fail:
D
David Teigland 已提交
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
	while (x--) {
		bi = rgd->rd_bits + x;
		brelse(bi->bi_bh);
		bi->bi_bh = NULL;
		gfs2_assert_warn(sdp, !bi->bi_clone);
	}

	return error;
}

1163 1164 1165 1166 1167 1168 1169
int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
{
	u32 rl_flags;

	if (rgd->rd_flags & GFS2_RDF_UPTODATE)
		return 0;

A
Al Viro 已提交
1170
	if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
		return gfs2_rgrp_bh_get(rgd);

	rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
	rl_flags &= ~GFS2_RDF_MASK;
	rgd->rd_flags &= GFS2_RDF_MASK;
	rgd->rd_flags |= (rl_flags | GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
	if (rgd->rd_rgl->rl_unlinked == 0)
		rgd->rd_flags &= ~GFS2_RDF_CHECK;
	rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
	rgd->rd_free_clone = rgd->rd_free;
	rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
	rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
	return 0;
}

int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
{
	struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
	struct gfs2_sbd *sdp = rgd->rd_sbd;

	if (gh->gh_flags & GL_SKIP && sdp->sd_args.ar_rgrplvb)
		return 0;
	return gfs2_rgrp_bh_get((struct gfs2_rgrpd *)gh->gh_gl->gl_object);
}

D
David Teigland 已提交
1196
/**
1197
 * gfs2_rgrp_go_unlock - Release RG bitmaps read in with gfs2_rgrp_bh_get()
1198
 * @gh: The glock holder for the resource group
D
David Teigland 已提交
1199 1200 1201
 *
 */

1202
void gfs2_rgrp_go_unlock(struct gfs2_holder *gh)
D
David Teigland 已提交
1203
{
1204
	struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1205
	int x, length = rgd->rd_length;
D
David Teigland 已提交
1206 1207 1208

	for (x = 0; x < length; x++) {
		struct gfs2_bitmap *bi = rgd->rd_bits + x;
1209 1210 1211 1212
		if (bi->bi_bh) {
			brelse(bi->bi_bh);
			bi->bi_bh = NULL;
		}
D
David Teigland 已提交
1213 1214 1215 1216
	}

}

S
Steven Whitehouse 已提交
1217
int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
1218
			     struct buffer_head *bh,
S
Steven Whitehouse 已提交
1219
			     const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
1220 1221 1222
{
	struct super_block *sb = sdp->sd_vfs;
	u64 blk;
1223
	sector_t start = 0;
1224
	sector_t nr_blks = 0;
1225 1226
	int rv;
	unsigned int x;
S
Steven Whitehouse 已提交
1227 1228
	u32 trimmed = 0;
	u8 diff;
1229 1230

	for (x = 0; x < bi->bi_len; x++) {
S
Steven Whitehouse 已提交
1231 1232 1233 1234 1235 1236 1237 1238 1239
		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));
		}
1240 1241 1242 1243 1244 1245
		diff &= 0x55;
		if (diff == 0)
			continue;
		blk = offset + ((bi->bi_start + x) * GFS2_NBBY);
		while(diff) {
			if (diff & 1) {
1246
				if (nr_blks == 0)
1247
					goto start_new_extent;
1248 1249 1250 1251
				if ((start + nr_blks) != blk) {
					if (nr_blks >= minlen) {
						rv = sb_issue_discard(sb,
							start, nr_blks,
S
Steven Whitehouse 已提交
1252 1253 1254
							GFP_NOFS, 0);
						if (rv)
							goto fail;
1255
						trimmed += nr_blks;
S
Steven Whitehouse 已提交
1256
					}
1257
					nr_blks = 0;
1258 1259 1260
start_new_extent:
					start = blk;
				}
1261
				nr_blks++;
1262 1263
			}
			diff >>= 2;
1264
			blk++;
1265 1266
		}
	}
1267 1268
	if (nr_blks >= minlen) {
		rv = sb_issue_discard(sb, start, nr_blks, GFP_NOFS, 0);
1269 1270
		if (rv)
			goto fail;
1271
		trimmed += nr_blks;
1272
	}
S
Steven Whitehouse 已提交
1273 1274 1275 1276
	if (ptrimmed)
		*ptrimmed = trimmed;
	return 0;

1277
fail:
S
Steven Whitehouse 已提交
1278 1279
	if (sdp->sd_args.ar_discard)
		fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem", rv);
1280
	sdp->sd_args.ar_discard = 0;
S
Steven Whitehouse 已提交
1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
	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)
{
A
Al Viro 已提交
1294
	struct inode *inode = file_inode(filp);
S
Steven Whitehouse 已提交
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
	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;
L
Lukas Czerner 已提交
1305
	u64 start, end, minlen;
S
Steven Whitehouse 已提交
1306
	unsigned int x;
L
Lukas Czerner 已提交
1307
	unsigned bs_shift = sdp->sd_sb.sb_bsize_shift;
S
Steven Whitehouse 已提交
1308 1309 1310 1311 1312 1313 1314

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

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

1315
	if (copy_from_user(&r, argp, sizeof(r)))
S
Steven Whitehouse 已提交
1316 1317
		return -EFAULT;

1318 1319 1320 1321
	ret = gfs2_rindex_update(sdp);
	if (ret)
		return ret;

L
Lukas Czerner 已提交
1322 1323 1324 1325 1326
	start = r.start >> bs_shift;
	end = start + (r.len >> bs_shift);
	minlen = max_t(u64, r.minlen,
		       q->limits.discard_granularity) >> bs_shift;

1327 1328 1329
	if (end <= start || minlen > sdp->sd_max_rg_data)
		return -EINVAL;

L
Lukas Czerner 已提交
1330
	rgd = gfs2_blk2rgrpd(sdp, start, 0);
1331
	rgd_end = gfs2_blk2rgrpd(sdp, end, 0);
L
Lukas Czerner 已提交
1332

1333 1334 1335
	if ((gfs2_rgrpd_get_first(sdp) == gfs2_rgrpd_get_next(rgd_end))
	    && (start > rgd_end->rd_data0 + rgd_end->rd_data))
		return -EINVAL; /* start is beyond the end of the fs */
S
Steven Whitehouse 已提交
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346

	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;
L
Lukas Czerner 已提交
1347 1348 1349
				ret = gfs2_rgrp_send_discards(sdp,
						rgd->rd_data0, NULL, bi, minlen,
						&amt);
S
Steven Whitehouse 已提交
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361
				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;
1362
				gfs2_trans_add_meta(rgd->rd_gl, bh);
S
Steven Whitehouse 已提交
1363
				gfs2_rgrp_out(rgd, bh->b_data);
1364
				gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, bh->b_data);
S
Steven Whitehouse 已提交
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
				gfs2_trans_end(sdp);
			}
		}
		gfs2_glock_dq_uninit(&gh);

		if (rgd == rgd_end)
			break;

		rgd = gfs2_rgrpd_get_next(rgd);
	}

out:
1377
	r.len = trimmed << bs_shift;
1378
	if (copy_to_user(argp, &r, sizeof(r)))
S
Steven Whitehouse 已提交
1379 1380 1381
		return -EFAULT;

	return ret;
1382 1383
}

B
Bob Peterson 已提交
1384 1385 1386 1387 1388
/**
 * rs_insert - insert a new multi-block reservation into the rgrp's rb_tree
 * @ip: the inode structure
 *
 */
1389
static void rs_insert(struct gfs2_inode *ip)
B
Bob Peterson 已提交
1390 1391 1392 1393
{
	struct rb_node **newn, *parent = NULL;
	int rc;
	struct gfs2_blkreserv *rs = ip->i_res;
1394
	struct gfs2_rgrpd *rgd = rs->rs_rbm.rgd;
1395
	u64 fsblock = gfs2_rbm_to_block(&rs->rs_rbm);
B
Bob Peterson 已提交
1396 1397

	BUG_ON(gfs2_rs_active(rs));
1398

1399 1400
	spin_lock(&rgd->rd_rsspin);
	newn = &rgd->rd_rstree.rb_node;
B
Bob Peterson 已提交
1401 1402 1403 1404 1405
	while (*newn) {
		struct gfs2_blkreserv *cur =
			rb_entry(*newn, struct gfs2_blkreserv, rs_node);

		parent = *newn;
1406
		rc = rs_cmp(fsblock, rs->rs_free, cur);
B
Bob Peterson 已提交
1407 1408 1409 1410 1411 1412
		if (rc > 0)
			newn = &((*newn)->rb_right);
		else if (rc < 0)
			newn = &((*newn)->rb_left);
		else {
			spin_unlock(&rgd->rd_rsspin);
1413 1414
			WARN_ON(1);
			return;
B
Bob Peterson 已提交
1415 1416 1417 1418 1419 1420 1421
		}
	}

	rb_link_node(&rs->rs_node, parent, newn);
	rb_insert_color(&rs->rs_node, &rgd->rd_rstree);

	/* Do our rgrp accounting for the reservation */
1422
	rgd->rd_reserved += rs->rs_free; /* blocks reserved */
B
Bob Peterson 已提交
1423
	spin_unlock(&rgd->rd_rsspin);
1424
	trace_gfs2_rs(rs, TRACE_RS_INSERT);
B
Bob Peterson 已提交
1425 1426 1427
}

/**
1428
 * rg_mblk_search - find a group of multiple free blocks to form a reservation
B
Bob Peterson 已提交
1429 1430
 * @rgd: the resource group descriptor
 * @ip: pointer to the inode for which we're reserving blocks
1431
 * @ap: the allocation parameters
B
Bob Peterson 已提交
1432 1433 1434
 *
 */

1435
static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
1436
			   const struct gfs2_alloc_parms *ap)
B
Bob Peterson 已提交
1437
{
1438 1439 1440 1441 1442 1443
	struct gfs2_rbm rbm = { .rgd = rgd, };
	u64 goal;
	struct gfs2_blkreserv *rs = ip->i_res;
	u32 extlen;
	u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
	int ret;
1444
	struct inode *inode = &ip->i_inode;
B
Bob Peterson 已提交
1445

1446 1447 1448
	if (S_ISDIR(inode->i_mode))
		extlen = 1;
	else {
1449
		extlen = max_t(u32, atomic_read(&rs->rs_sizehint), ap->target);
1450 1451
		extlen = clamp(extlen, RGRP_RSRV_MINBLKS, free_blocks);
	}
1452
	if ((rgd->rd_free_clone < rgd->rd_reserved) || (free_blocks < extlen))
1453 1454
		return;

B
Bob Peterson 已提交
1455 1456
	/* Find bitmap block that contains bits for goal block */
	if (rgrp_contains_block(rgd, ip->i_goal))
1457
		goal = ip->i_goal;
B
Bob Peterson 已提交
1458
	else
1459
		goal = rgd->rd_last_alloc + rgd->rd_data0;
B
Bob Peterson 已提交
1460

1461 1462
	if (WARN_ON(gfs2_rbm_from_block(&rbm, goal)))
		return;
B
Bob Peterson 已提交
1463

1464
	ret = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &extlen, ip, true, ap);
1465 1466 1467 1468 1469
	if (ret == 0) {
		rs->rs_rbm = rbm;
		rs->rs_free = extlen;
		rs->rs_inum = ip->i_no_addr;
		rs_insert(ip);
1470 1471 1472
	} else {
		if (goal == rgd->rd_last_alloc + rgd->rd_data0)
			rgd->rd_last_alloc = 0;
B
Bob Peterson 已提交
1473
	}
B
Bob Peterson 已提交
1474 1475
}

1476 1477 1478 1479
/**
 * gfs2_next_unreserved_block - Return next block that is not reserved
 * @rgd: The resource group
 * @block: The starting block
1480
 * @length: The required length
1481 1482 1483 1484 1485 1486 1487 1488 1489
 * @ip: Ignore any reservations for this inode
 *
 * If the block does not appear in any reservation, then return the
 * block number unchanged. If it does appear in the reservation, then
 * keep looking through the tree of reservations in order to find the
 * first block number which is not reserved.
 */

static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
1490
				      u32 length,
1491 1492 1493 1494 1495 1496 1497
				      const struct gfs2_inode *ip)
{
	struct gfs2_blkreserv *rs;
	struct rb_node *n;
	int rc;

	spin_lock(&rgd->rd_rsspin);
1498
	n = rgd->rd_rstree.rb_node;
1499 1500
	while (n) {
		rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1501
		rc = rs_cmp(block, length, rs);
1502 1503 1504 1505 1506 1507 1508 1509 1510
		if (rc < 0)
			n = n->rb_left;
		else if (rc > 0)
			n = n->rb_right;
		else
			break;
	}

	if (n) {
1511
		while ((rs_cmp(block, length, rs) == 0) && (ip->i_res != rs)) {
1512
			block = gfs2_rbm_to_block(&rs->rs_rbm) + rs->rs_free;
1513
			n = n->rb_right;
1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
			if (n == NULL)
				break;
			rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
		}
	}

	spin_unlock(&rgd->rd_rsspin);
	return block;
}

/**
 * gfs2_reservation_check_and_update - Check for reservations during block alloc
 * @rbm: The current position in the resource group
1527 1528
 * @ip: The inode for which we are searching for blocks
 * @minext: The minimum extent length
1529
 * @maxext: A pointer to the maximum extent structure
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540
 *
 * This checks the current position in the rgrp to see whether there is
 * a reservation covering this block. If not then this function is a
 * no-op. If there is, then the position is moved to the end of the
 * contiguous reservation(s) so that we are pointing at the first
 * non-reserved block.
 *
 * Returns: 0 if no reservation, 1 if @rbm has changed, otherwise an error
 */

static int gfs2_reservation_check_and_update(struct gfs2_rbm *rbm,
1541
					     const struct gfs2_inode *ip,
1542 1543
					     u32 minext,
					     struct gfs2_extent *maxext)
1544 1545
{
	u64 block = gfs2_rbm_to_block(rbm);
1546
	u32 extlen = 1;
1547 1548 1549
	u64 nblock;
	int ret;

1550 1551 1552 1553 1554 1555
	/*
	 * If we have a minimum extent length, then skip over any extent
	 * which is less than the min extent length in size.
	 */
	if (minext) {
		extlen = gfs2_free_extlen(rbm, minext);
1556
		if (extlen <= maxext->len)
1557 1558 1559 1560 1561 1562 1563 1564
			goto fail;
	}

	/*
	 * Check the extent which has been found against the reservations
	 * and skip if parts of it are already reserved
	 */
	nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, ip);
1565 1566 1567 1568 1569 1570 1571 1572
	if (nblock == block) {
		if (!minext || extlen >= minext)
			return 0;

		if (extlen > maxext->len) {
			maxext->len = extlen;
			maxext->rbm = *rbm;
		}
1573
fail:
1574 1575
		nblock = block + extlen;
	}
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585
	ret = gfs2_rbm_from_block(rbm, nblock);
	if (ret < 0)
		return ret;
	return 1;
}

/**
 * gfs2_rbm_find - Look for blocks of a particular state
 * @rbm: Value/result starting position and final position
 * @state: The state which we want to find
1586 1587
 * @minext: Pointer to the requested extent length (NULL for a single block)
 *          This is updated to be the actual reservation size.
1588 1589 1590
 * @ip: If set, check for reservations
 * @nowrap: Stop looking at the end of the rgrp, rather than wrapping
 *          around until we've reached the starting point.
1591
 * @ap: the allocation parameters
1592 1593 1594 1595 1596 1597 1598 1599
 *
 * Side effects:
 * - If looking for free blocks, we set GBF_FULL on each bitmap which
 *   has no free blocks in it.
 *
 * Returns: 0 on success, -ENOSPC if there is no block of the requested state
 */

1600 1601 1602
static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 *minext,
			 const struct gfs2_inode *ip, bool nowrap,
			 const struct gfs2_alloc_parms *ap)
1603 1604
{
	struct buffer_head *bh;
B
Bob Peterson 已提交
1605
	int initial_bii;
1606 1607 1608 1609 1610 1611
	u32 initial_offset;
	u32 offset;
	u8 *buffer;
	int n = 0;
	int iters = rbm->rgd->rd_length;
	int ret;
B
Bob Peterson 已提交
1612
	struct gfs2_bitmap *bi;
1613
	struct gfs2_extent maxext = { .rbm.rgd = rbm->rgd, };
1614 1615 1616 1617 1618 1619 1620 1621 1622

	/* If we are not starting at the beginning of a bitmap, then we
	 * need to add one to the bitmap count to ensure that we search
	 * the starting bitmap twice.
	 */
	if (rbm->offset != 0)
		iters++;

	while(1) {
B
Bob Peterson 已提交
1623 1624
		bi = rbm_bi(rbm);
		if (test_bit(GBF_FULL, &bi->bi_flags) &&
1625 1626 1627
		    (state == GFS2_BLKST_FREE))
			goto next_bitmap;

B
Bob Peterson 已提交
1628 1629
		bh = bi->bi_bh;
		buffer = bh->b_data + bi->bi_offset;
1630
		WARN_ON(!buffer_uptodate(bh));
B
Bob Peterson 已提交
1631 1632
		if (state != GFS2_BLKST_UNLINKED && bi->bi_clone)
			buffer = bi->bi_clone + bi->bi_offset;
1633
		initial_offset = rbm->offset;
B
Bob Peterson 已提交
1634
		offset = gfs2_bitfit(buffer, bi->bi_len, rbm->offset, state);
1635 1636 1637 1638 1639 1640
		if (offset == BFITNOENT)
			goto bitmap_full;
		rbm->offset = offset;
		if (ip == NULL)
			return 0;

B
Bob Peterson 已提交
1641
		initial_bii = rbm->bii;
1642 1643 1644
		ret = gfs2_reservation_check_and_update(rbm, ip,
							minext ? *minext : 0,
							&maxext);
1645 1646 1647
		if (ret == 0)
			return 0;
		if (ret > 0) {
B
Bob Peterson 已提交
1648
			n += (rbm->bii - initial_bii);
B
Bob Peterson 已提交
1649
			goto next_iter;
1650
		}
1651
		if (ret == -E2BIG) {
B
Bob Peterson 已提交
1652
			rbm->bii = 0;
1653
			rbm->offset = 0;
B
Bob Peterson 已提交
1654
			n += (rbm->bii - initial_bii);
1655 1656
			goto res_covered_end_of_rgrp;
		}
1657 1658 1659
		return ret;

bitmap_full:	/* Mark bitmap as full and fall through */
B
Bob Peterson 已提交
1660 1661 1662 1663
		if ((state == GFS2_BLKST_FREE) && initial_offset == 0) {
			struct gfs2_bitmap *bi = rbm_bi(rbm);
			set_bit(GBF_FULL, &bi->bi_flags);
		}
1664 1665 1666

next_bitmap:	/* Find next bitmap in the rgrp */
		rbm->offset = 0;
B
Bob Peterson 已提交
1667 1668 1669
		rbm->bii++;
		if (rbm->bii == rbm->rgd->rd_length)
			rbm->bii = 0;
1670
res_covered_end_of_rgrp:
B
Bob Peterson 已提交
1671
		if ((rbm->bii == 0) && nowrap)
1672 1673
			break;
		n++;
B
Bob Peterson 已提交
1674
next_iter:
1675 1676 1677 1678
		if (n >= iters)
			break;
	}

1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689
	if (minext == NULL || state != GFS2_BLKST_FREE)
		return -ENOSPC;

	/* If the maximum extent we found is big enough to fulfill the
	   minimum requirements, use it anyway. */
	if (maxext.len) {
		*rbm = maxext.rbm;
		*minext = maxext.len;
		return 0;
	}

1690 1691 1692
	return -ENOSPC;
}

1693 1694 1695
/**
 * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
 * @rgd: The rgrp
1696 1697
 * @last_unlinked: block address of the last dinode we unlinked
 * @skip: block address we should explicitly not unlink
1698
 *
B
Bob Peterson 已提交
1699 1700
 * Returns: 0 if no error
 *          The inode, if one has been found, in inode.
1701 1702
 */

1703
static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
1704
{
1705
	u64 block;
1706
	struct gfs2_sbd *sdp = rgd->rd_sbd;
1707 1708 1709 1710
	struct gfs2_glock *gl;
	struct gfs2_inode *ip;
	int error;
	int found = 0;
B
Bob Peterson 已提交
1711
	struct gfs2_rbm rbm = { .rgd = rgd, .bii = 0, .offset = 0 };
1712

1713
	while (1) {
1714
		down_write(&sdp->sd_log_flush_lock);
1715 1716
		error = gfs2_rbm_find(&rbm, GFS2_BLKST_UNLINKED, NULL, NULL,
				      true, NULL);
1717
		up_write(&sdp->sd_log_flush_lock);
1718 1719 1720
		if (error == -ENOSPC)
			break;
		if (WARN_ON_ONCE(error))
1721
			break;
B
Bob Peterson 已提交
1722

1723 1724 1725 1726
		block = gfs2_rbm_to_block(&rbm);
		if (gfs2_rbm_from_block(&rbm, block + 1))
			break;
		if (*last_unlinked != NO_BLOCK && block <= *last_unlinked)
1727
			continue;
1728
		if (block == skip)
1729
			continue;
1730
		*last_unlinked = block;
1731

1732
		error = gfs2_glock_get(sdp, block, &gfs2_inode_glops, CREATE, &gl);
1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750
		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 */
1751
		if (found > NR_CPUS)
1752
			return;
1753 1754 1755
	}

	rgd->rd_flags &= ~GFS2_RDF_CHECK;
1756
	return;
1757 1758
}

1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840
/**
 * gfs2_rgrp_congested - Use stats to figure out whether an rgrp is congested
 * @rgd: The rgrp in question
 * @loops: An indication of how picky we can be (0=very, 1=less so)
 *
 * This function uses the recently added glock statistics in order to
 * figure out whether a parciular resource group is suffering from
 * contention from multiple nodes. This is done purely on the basis
 * of timings, since this is the only data we have to work with and
 * our aim here is to reject a resource group which is highly contended
 * but (very important) not to do this too often in order to ensure that
 * we do not land up introducing fragmentation by changing resource
 * groups when not actually required.
 *
 * The calculation is fairly simple, we want to know whether the SRTTB
 * (i.e. smoothed round trip time for blocking operations) to acquire
 * the lock for this rgrp's glock is significantly greater than the
 * time taken for resource groups on average. We introduce a margin in
 * the form of the variable @var which is computed as the sum of the two
 * respective variences, and multiplied by a factor depending on @loops
 * and whether we have a lot of data to base the decision on. This is
 * then tested against the square difference of the means in order to
 * decide whether the result is statistically significant or not.
 *
 * Returns: A boolean verdict on the congestion status
 */

static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
{
	const struct gfs2_glock *gl = rgd->rd_gl;
	const struct gfs2_sbd *sdp = gl->gl_sbd;
	struct gfs2_lkstats *st;
	s64 r_dcount, l_dcount;
	s64 r_srttb, l_srttb;
	s64 srttb_diff;
	s64 sqr_diff;
	s64 var;

	preempt_disable();
	st = &this_cpu_ptr(sdp->sd_lkstats)->lkstats[LM_TYPE_RGRP];
	r_srttb = st->stats[GFS2_LKS_SRTTB];
	r_dcount = st->stats[GFS2_LKS_DCOUNT];
	var = st->stats[GFS2_LKS_SRTTVARB] +
	      gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
	preempt_enable();

	l_srttb = gl->gl_stats.stats[GFS2_LKS_SRTTB];
	l_dcount = gl->gl_stats.stats[GFS2_LKS_DCOUNT];

	if ((l_dcount < 1) || (r_dcount < 1) || (r_srttb == 0))
		return false;

	srttb_diff = r_srttb - l_srttb;
	sqr_diff = srttb_diff * srttb_diff;

	var *= 2;
	if (l_dcount < 8 || r_dcount < 8)
		var *= 2;
	if (loops == 1)
		var *= 2;

	return ((srttb_diff < 0) && (sqr_diff > var));
}

/**
 * gfs2_rgrp_used_recently
 * @rs: The block reservation with the rgrp to test
 * @msecs: The time limit in milliseconds
 *
 * Returns: True if the rgrp glock has been used within the time limit
 */
static bool gfs2_rgrp_used_recently(const struct gfs2_blkreserv *rs,
				    u64 msecs)
{
	u64 tdiff;

	tdiff = ktime_to_ns(ktime_sub(ktime_get_real(),
                            rs->rs_rbm.rgd->rd_gl->gl_dstamp));

	return tdiff > (msecs * 1000 * 1000);
}

S
Steven Whitehouse 已提交
1841 1842 1843 1844 1845 1846 1847 1848 1849
static u32 gfs2_orlov_skip(const struct gfs2_inode *ip)
{
	const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	u32 skip;

	get_random_bytes(&skip, sizeof(skip));
	return skip % sdp->sd_rgrps;
}

1850 1851 1852
static bool gfs2_select_rgrp(struct gfs2_rgrpd **pos, const struct gfs2_rgrpd *begin)
{
	struct gfs2_rgrpd *rgd = *pos;
S
Steven Whitehouse 已提交
1853
	struct gfs2_sbd *sdp = rgd->rd_sbd;
1854 1855 1856

	rgd = gfs2_rgrpd_get_next(rgd);
	if (rgd == NULL)
S
Steven Whitehouse 已提交
1857
		rgd = gfs2_rgrpd_get_first(sdp);
1858 1859 1860 1861 1862 1863
	*pos = rgd;
	if (rgd != begin) /* If we didn't wrap */
		return true;
	return false;
}

D
David Teigland 已提交
1864
/**
1865
 * gfs2_inplace_reserve - Reserve space in the filesystem
D
David Teigland 已提交
1866
 * @ip: the inode to reserve space for
1867
 * @ap: the allocation parameters
D
David Teigland 已提交
1868 1869 1870 1871
 *
 * Returns: errno
 */

1872
int gfs2_inplace_reserve(struct gfs2_inode *ip, const struct gfs2_alloc_parms *ap)
D
David Teigland 已提交
1873
{
1874
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
B
Bob Peterson 已提交
1875
	struct gfs2_rgrpd *begin = NULL;
1876
	struct gfs2_blkreserv *rs = ip->i_res;
1877
	int error = 0, rg_locked, flags = 0;
1878
	u64 last_unlinked = NO_BLOCK;
1879
	int loops = 0;
S
Steven Whitehouse 已提交
1880
	u32 skip = 0;
D
David Teigland 已提交
1881

1882 1883
	if (sdp->sd_args.ar_rgrplvb)
		flags |= GL_SKIP;
1884
	if (gfs2_assert_warn(sdp, ap->target))
1885
		return -EINVAL;
B
Bob Peterson 已提交
1886
	if (gfs2_rs_active(rs)) {
1887
		begin = rs->rs_rbm.rgd;
B
Bob Peterson 已提交
1888
	} else if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, ip->i_goal)) {
1889
		rs->rs_rbm.rgd = begin = ip->i_rgd;
B
Bob Peterson 已提交
1890
	} else {
1891
		rs->rs_rbm.rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
B
Bob Peterson 已提交
1892
	}
1893
	if (S_ISDIR(ip->i_inode.i_mode) && (ap->aflags & GFS2_AF_ORLOV))
S
Steven Whitehouse 已提交
1894
		skip = gfs2_orlov_skip(ip);
1895
	if (rs->rs_rbm.rgd == NULL)
1896 1897 1898
		return -EBADSLT;

	while (loops < 3) {
1899 1900 1901 1902
		rg_locked = 1;

		if (!gfs2_glock_is_locked_by_me(rs->rs_rbm.rgd->rd_gl)) {
			rg_locked = 0;
S
Steven Whitehouse 已提交
1903 1904
			if (skip && skip--)
				goto next_rgrp;
1905 1906 1907 1908
			if (!gfs2_rs_active(rs) && (loops < 2) &&
			     gfs2_rgrp_used_recently(rs, 1000) &&
			     gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
				goto next_rgrp;
1909
			error = gfs2_glock_nq_init(rs->rs_rbm.rgd->rd_gl,
B
Bob Peterson 已提交
1910 1911
						   LM_ST_EXCLUSIVE, flags,
						   &rs->rs_rgd_gh);
1912 1913
			if (unlikely(error))
				return error;
1914 1915 1916
			if (!gfs2_rs_active(rs) && (loops < 2) &&
			    gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
				goto skip_rgrp;
1917
			if (sdp->sd_args.ar_rgrplvb) {
1918
				error = update_rgrp_lvb(rs->rs_rbm.rgd);
1919
				if (unlikely(error)) {
1920 1921 1922 1923
					gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
					return error;
				}
			}
1924
		}
1925

1926 1927 1928 1929 1930 1931 1932 1933 1934
		/* Skip unuseable resource groups */
		if (rs->rs_rbm.rgd->rd_flags & (GFS2_RGF_NOALLOC | GFS2_RDF_ERROR))
			goto skip_rgrp;

		if (sdp->sd_args.ar_rgrplvb)
			gfs2_rgrp_bh_get(rs->rs_rbm.rgd);

		/* Get a reservation if we don't already have one */
		if (!gfs2_rs_active(rs))
1935
			rg_mblk_search(rs->rs_rbm.rgd, ip, ap);
1936 1937 1938 1939 1940 1941

		/* Skip rgrps when we can't get a reservation on first pass */
		if (!gfs2_rs_active(rs) && (loops < 1))
			goto check_rgrp;

		/* If rgrp has enough free space, use it */
1942
		if (rs->rs_rbm.rgd->rd_free_clone >= ap->target) {
1943 1944
			ip->i_rgd = rs->rs_rbm.rgd;
			return 0;
D
David Teigland 已提交
1945
		}
1946 1947 1948

		/* Drop reservation, if we couldn't use reserved rgrp */
		if (gfs2_rs_active(rs))
1949
			gfs2_rs_deltree(rs);
1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
check_rgrp:
		/* Check for unlinked inodes which can be reclaimed */
		if (rs->rs_rbm.rgd->rd_flags & GFS2_RDF_CHECK)
			try_rgrp_unlink(rs->rs_rbm.rgd, &last_unlinked,
					ip->i_no_addr);
skip_rgrp:
		/* Unlock rgrp if required */
		if (!rg_locked)
			gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
next_rgrp:
		/* Find the next rgrp, and continue looking */
		if (gfs2_select_rgrp(&rs->rs_rbm.rgd, begin))
			continue;
S
Steven Whitehouse 已提交
1963 1964
		if (skip)
			continue;
1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979

		/* If we've scanned all the rgrps, but found no free blocks
		 * then this checks for some less likely conditions before
		 * trying again.
		 */
		loops++;
		/* 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)
				return error;
		}
		/* Flushing the log may release space */
		if (loops == 2)
			gfs2_log_flush(sdp, NULL);
D
David Teigland 已提交
1980 1981
	}

1982
	return -ENOSPC;
D
David Teigland 已提交
1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993
}

/**
 * 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)
{
1994
	struct gfs2_blkreserv *rs = ip->i_res;
D
David Teigland 已提交
1995

1996 1997
	if (rs->rs_rgd_gh.gh_gl)
		gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
D
David Teigland 已提交
1998 1999 2000 2001 2002 2003 2004 2005 2006 2007
}

/**
 * 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_*)
 */

2008
static unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
D
David Teigland 已提交
2009
{
2010 2011
	struct gfs2_rbm rbm = { .rgd = rgd, };
	int ret;
D
David Teigland 已提交
2012

2013 2014
	ret = gfs2_rbm_from_block(&rbm, block);
	WARN_ON_ONCE(ret != 0);
D
David Teigland 已提交
2015

2016
	return gfs2_testbit(&rbm);
D
David Teigland 已提交
2017 2018
}

2019

B
Bob Peterson 已提交
2020 2021
/**
 * gfs2_alloc_extent - allocate an extent from a given bitmap
2022
 * @rbm: the resource group information
B
Bob Peterson 已提交
2023
 * @dinode: TRUE if the first block we allocate is for a dinode
2024
 * @n: The extent length (value/result)
B
Bob Peterson 已提交
2025
 *
2026
 * Add the bitmap buffer to the transaction.
B
Bob Peterson 已提交
2027 2028
 * Set the found bits to @new_state to change block's allocation state.
 */
2029
static void gfs2_alloc_extent(const struct gfs2_rbm *rbm, bool dinode,
2030
			     unsigned int *n)
B
Bob Peterson 已提交
2031
{
2032
	struct gfs2_rbm pos = { .rgd = rbm->rgd, };
B
Bob Peterson 已提交
2033
	const unsigned int elen = *n;
2034 2035
	u64 block;
	int ret;
B
Bob Peterson 已提交
2036

2037 2038
	*n = 1;
	block = gfs2_rbm_to_block(rbm);
B
Bob Peterson 已提交
2039
	gfs2_trans_add_meta(rbm->rgd->rd_gl, rbm_bi(rbm)->bi_bh);
2040
	gfs2_setbit(rbm, true, dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
2041
	block++;
2042
	while (*n < elen) {
2043
		ret = gfs2_rbm_from_block(&pos, block);
2044
		if (ret || gfs2_testbit(&pos) != GFS2_BLKST_FREE)
2045
			break;
B
Bob Peterson 已提交
2046
		gfs2_trans_add_meta(pos.rgd->rd_gl, rbm_bi(&pos)->bi_bh);
2047
		gfs2_setbit(&pos, true, GFS2_BLKST_USED);
2048
		(*n)++;
2049
		block++;
2050
	}
D
David Teigland 已提交
2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062
}

/**
 * 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)
 */

2063 2064
static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
				     u32 blen, unsigned char new_state)
D
David Teigland 已提交
2065
{
2066
	struct gfs2_rbm rbm;
B
Bob Peterson 已提交
2067
	struct gfs2_bitmap *bi;
D
David Teigland 已提交
2068

2069 2070
	rbm.rgd = gfs2_blk2rgrpd(sdp, bstart, 1);
	if (!rbm.rgd) {
D
David Teigland 已提交
2071
		if (gfs2_consist(sdp))
2072
			fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);
D
David Teigland 已提交
2073 2074 2075 2076
		return NULL;
	}

	while (blen--) {
2077
		gfs2_rbm_from_block(&rbm, bstart);
B
Bob Peterson 已提交
2078
		bi = rbm_bi(&rbm);
2079
		bstart++;
B
Bob Peterson 已提交
2080 2081 2082 2083 2084
		if (!bi->bi_clone) {
			bi->bi_clone = kmalloc(bi->bi_bh->b_size,
					       GFP_NOFS | __GFP_NOFAIL);
			memcpy(bi->bi_clone + bi->bi_offset,
			       bi->bi_bh->b_data + bi->bi_offset, bi->bi_len);
D
David Teigland 已提交
2085
		}
B
Bob Peterson 已提交
2086
		gfs2_trans_add_meta(rbm.rgd->rd_gl, bi->bi_bh);
2087
		gfs2_setbit(&rbm, false, new_state);
D
David Teigland 已提交
2088 2089
	}

2090
	return rbm.rgd;
D
David Teigland 已提交
2091 2092 2093
}

/**
2094 2095 2096 2097 2098 2099 2100 2101
 * 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)
{
B
Bob Peterson 已提交
2102 2103 2104 2105
	struct gfs2_rgrpd *rgd = gl->gl_object;
	struct gfs2_blkreserv *trs;
	const struct rb_node *n;

2106 2107
	if (rgd == NULL)
		return 0;
B
Bob Peterson 已提交
2108
	gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u r:%u\n",
2109
		       (unsigned long long)rgd->rd_addr, rgd->rd_flags,
B
Bob Peterson 已提交
2110 2111 2112 2113 2114 2115 2116 2117
		       rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
		       rgd->rd_reserved);
	spin_lock(&rgd->rd_rsspin);
	for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
		trs = rb_entry(n, struct gfs2_blkreserv, rs_node);
		dump_rs(seq, trs);
	}
	spin_unlock(&rgd->rd_rsspin);
2118 2119 2120
	return 0;
}

2121 2122 2123 2124
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 已提交
2125
		(unsigned long long)rgd->rd_addr);
2126 2127 2128 2129 2130
	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;
}

B
Bob Peterson 已提交
2131
/**
2132 2133 2134 2135
 * gfs2_adjust_reservation - Adjust (or remove) a reservation after allocation
 * @ip: The inode we have just allocated blocks for
 * @rbm: The start of the allocated blocks
 * @len: The extent length
B
Bob Peterson 已提交
2136
 *
2137 2138 2139
 * Adjusts a reservation after an allocation has taken place. If the
 * reservation does not match the allocation, or if it is now empty
 * then it is removed.
B
Bob Peterson 已提交
2140
 */
2141 2142 2143

static void gfs2_adjust_reservation(struct gfs2_inode *ip,
				    const struct gfs2_rbm *rbm, unsigned len)
B
Bob Peterson 已提交
2144 2145
{
	struct gfs2_blkreserv *rs = ip->i_res;
2146 2147 2148 2149
	struct gfs2_rgrpd *rgd = rbm->rgd;
	unsigned rlen;
	u64 block;
	int ret;
B
Bob Peterson 已提交
2150

2151 2152 2153 2154 2155 2156 2157 2158
	spin_lock(&rgd->rd_rsspin);
	if (gfs2_rs_active(rs)) {
		if (gfs2_rbm_eq(&rs->rs_rbm, rbm)) {
			block = gfs2_rbm_to_block(rbm);
			ret = gfs2_rbm_from_block(&rs->rs_rbm, block + len);
			rlen = min(rs->rs_free, len);
			rs->rs_free -= rlen;
			rgd->rd_reserved -= rlen;
2159
			trace_gfs2_rs(rs, TRACE_RS_CLAIM);
2160 2161 2162
			if (rs->rs_free && !ret)
				goto out;
		}
2163
		__rs_deltree(rs);
B
Bob Peterson 已提交
2164
	}
2165 2166
out:
	spin_unlock(&rgd->rd_rsspin);
B
Bob Peterson 已提交
2167 2168
}

2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197
/**
 * gfs2_set_alloc_start - Set starting point for block allocation
 * @rbm: The rbm which will be set to the required location
 * @ip: The gfs2 inode
 * @dinode: Flag to say if allocation includes a new inode
 *
 * This sets the starting point from the reservation if one is active
 * otherwise it falls back to guessing a start point based on the
 * inode's goal block or the last allocation point in the rgrp.
 */

static void gfs2_set_alloc_start(struct gfs2_rbm *rbm,
				 const struct gfs2_inode *ip, bool dinode)
{
	u64 goal;

	if (gfs2_rs_active(ip->i_res)) {
		*rbm = ip->i_res->rs_rbm;
		return;
	}

	if (!dinode && rgrp_contains_block(rbm->rgd, ip->i_goal))
		goal = ip->i_goal;
	else
		goal = rbm->rgd->rd_last_alloc + rbm->rgd->rd_data0;

	gfs2_rbm_from_block(rbm, goal);
}

2198
/**
2199
 * gfs2_alloc_blocks - Allocate one or more blocks of data and/or a dinode
2200
 * @ip: the inode to allocate the block for
2201
 * @bn: Used to return the starting block number
B
Bob Peterson 已提交
2202
 * @nblocks: requested number of blocks/extent length (value/result)
2203
 * @dinode: 1 if we're allocating a dinode block, else 0
2204
 * @generation: the generation number of the inode
D
David Teigland 已提交
2205
 *
2206
 * Returns: 0 or error
D
David Teigland 已提交
2207 2208
 */

2209
int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
2210
		      bool dinode, u64 *generation)
D
David Teigland 已提交
2211
{
2212
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2213
	struct buffer_head *dibh;
2214
	struct gfs2_rbm rbm = { .rgd = ip->i_rgd, };
2215
	unsigned int ndata;
2216
	u64 block; /* block, within the file system scope */
2217
	int error;
D
David Teigland 已提交
2218

2219
	gfs2_set_alloc_start(&rbm, ip, dinode);
2220
	error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, NULL, ip, false, NULL);
2221

2222
	if (error == -ENOSPC) {
2223
		gfs2_set_alloc_start(&rbm, ip, dinode);
2224 2225
		error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, NULL, NULL, false,
				      NULL);
2226 2227
	}

2228
	/* Since all blocks are reserved in advance, this shouldn't happen */
2229
	if (error) {
2230 2231
		fs_warn(sdp, "inum=%llu error=%d, nblocks=%u, full=%d\n",
			(unsigned long long)ip->i_no_addr, error, *nblocks,
2232
			test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags));
2233
		goto rgrp_error;
B
Bob Peterson 已提交
2234
	}
2235

2236 2237
	gfs2_alloc_extent(&rbm, dinode, nblocks);
	block = gfs2_rbm_to_block(&rbm);
2238
	rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
2239 2240
	if (gfs2_rs_active(ip->i_res))
		gfs2_adjust_reservation(ip, &rbm, *nblocks);
2241 2242 2243
	ndata = *nblocks;
	if (dinode)
		ndata--;
B
Bob Peterson 已提交
2244

2245
	if (!dinode) {
2246
		ip->i_goal = block + ndata - 1;
2247 2248 2249 2250
		error = gfs2_meta_inode_buffer(ip, &dibh);
		if (error == 0) {
			struct gfs2_dinode *di =
				(struct gfs2_dinode *)dibh->b_data;
2251
			gfs2_trans_add_meta(ip->i_gl, dibh);
2252 2253 2254 2255
			di->di_goal_meta = di->di_goal_data =
				cpu_to_be64(ip->i_goal);
			brelse(dibh);
		}
2256
	}
2257
	if (rbm.rgd->rd_free < *nblocks) {
B
Bob Peterson 已提交
2258
		printk(KERN_WARNING "nblocks=%u\n", *nblocks);
2259
		goto rgrp_error;
B
Bob Peterson 已提交
2260
	}
2261

2262
	rbm.rgd->rd_free -= *nblocks;
2263
	if (dinode) {
2264 2265
		rbm.rgd->rd_dinodes++;
		*generation = rbm.rgd->rd_igeneration++;
2266
		if (*generation == 0)
2267
			*generation = rbm.rgd->rd_igeneration++;
2268
	}
D
David Teigland 已提交
2269

2270
	gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh);
2271 2272
	gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
	gfs2_rgrp_ondisk2lvb(rbm.rgd->rd_rgl, rbm.rgd->rd_bits[0].bi_bh->b_data);
D
David Teigland 已提交
2273

2274
	gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
2275 2276
	if (dinode)
		gfs2_trans_add_unrevoke(sdp, block, 1);
2277

2278
	gfs2_quota_change(ip, *nblocks, ip->i_inode.i_uid, ip->i_inode.i_gid);
D
David Teigland 已提交
2279

2280 2281
	rbm.rgd->rd_free_clone -= *nblocks;
	trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
2282
			       dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
2283 2284 2285 2286
	*bn = block;
	return 0;

rgrp_error:
2287
	gfs2_rgrp_error(rbm.rgd);
2288
	return -EIO;
D
David Teigland 已提交
2289 2290 2291
}

/**
2292
 * __gfs2_free_blocks - free a contiguous run of block(s)
D
David Teigland 已提交
2293 2294 2295
 * @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
2296
 * @meta: 1 if the blocks represent metadata
D
David Teigland 已提交
2297 2298 2299
 *
 */

2300
void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta)
D
David Teigland 已提交
2301
{
2302
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
2303 2304 2305 2306 2307
	struct gfs2_rgrpd *rgd;

	rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
	if (!rgd)
		return;
2308
	trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
2309
	rgd->rd_free += blen;
S
Steven Whitehouse 已提交
2310
	rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
2311
	gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2312
	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2313
	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
D
David Teigland 已提交
2314

2315
	/* Directories keep their data in the metadata address space */
2316
	if (meta || ip->i_depth)
2317
		gfs2_meta_wipe(ip, bstart, blen);
2318
}
D
David Teigland 已提交
2319

2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331
/**
 * 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);

2332
	__gfs2_free_blocks(ip, bstart, blen, 1);
D
David Teigland 已提交
2333
	gfs2_statfs_change(sdp, 0, +blen, 0);
2334
	gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
D
David Teigland 已提交
2335 2336
}

2337 2338 2339 2340 2341
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;
2342
	u64 blkno = ip->i_no_addr;
2343 2344 2345 2346

	rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);
	if (!rgd)
		return;
2347
	trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
2348
	gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2349
	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2350 2351
	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
	update_rgrp_lvb_unlinked(rgd, 1);
2352 2353
}

2354
static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
D
David Teigland 已提交
2355 2356 2357 2358 2359 2360 2361 2362 2363
{
	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);

2364
	if (!rgd->rd_dinodes)
D
David Teigland 已提交
2365
		gfs2_consist_rgrpd(rgd);
2366
	rgd->rd_dinodes--;
2367
	rgd->rd_free++;
D
David Teigland 已提交
2368

2369
	gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2370
	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2371 2372
	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
	update_rgrp_lvb_unlinked(rgd, -1);
D
David Teigland 已提交
2373 2374 2375 2376 2377 2378 2379

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


void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
{
2380
	gfs2_free_uninit_di(rgd, ip->i_no_addr);
2381
	trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
2382
	gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
2383
	gfs2_meta_wipe(ip, ip->i_no_addr, 1);
D
David Teigland 已提交
2384 2385
}

2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399
/**
 * 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;
2400
	struct gfs2_holder rgd_gh;
2401
	int error = -EINVAL;
2402

S
Steven Whitehouse 已提交
2403
	rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
2404
	if (!rgd)
2405
		goto fail;
2406 2407 2408

	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
	if (error)
2409
		goto fail;
2410 2411 2412 2413 2414 2415 2416 2417 2418

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

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

D
David Teigland 已提交
2419 2420
/**
 * gfs2_rlist_add - add a RG to a list of RGs
2421
 * @ip: the inode
D
David Teigland 已提交
2422 2423 2424 2425 2426 2427 2428 2429 2430
 * @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
 *
 */

2431
void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
2432
		    u64 block)
D
David Teigland 已提交
2433
{
2434
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
2435 2436 2437 2438 2439 2440 2441 2442
	struct gfs2_rgrpd *rgd;
	struct gfs2_rgrpd **tmp;
	unsigned int new_space;
	unsigned int x;

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

2443 2444 2445
	if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, block))
		rgd = ip->i_rgd;
	else
S
Steven Whitehouse 已提交
2446
		rgd = gfs2_blk2rgrpd(sdp, block, 1);
D
David Teigland 已提交
2447
	if (!rgd) {
2448
		fs_err(sdp, "rlist_add: no rgrp for block %llu\n", (unsigned long long)block);
D
David Teigland 已提交
2449 2450
		return;
	}
2451
	ip->i_rgd = rgd;
D
David Teigland 已提交
2452 2453 2454 2455 2456 2457 2458 2459 2460

	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 *),
2461
			      GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485

		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
 *
 * FIXME: Don't use NOFAIL
 *
 */

2486
void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state)
D
David Teigland 已提交
2487 2488 2489 2490
{
	unsigned int x;

	rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder),
2491
				GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
2492 2493
	for (x = 0; x < rlist->rl_rgrps; x++)
		gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
2494
				state, 0,
D
David Teigland 已提交
2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513
				&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);
B
Bob Peterson 已提交
2514
		rlist->rl_ghs = NULL;
D
David Teigland 已提交
2515 2516 2517
	}
}