rgrp.c 59.9 KB
Newer Older
D
David Teigland 已提交
1 2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3
 * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
D
David Teigland 已提交
4 5 6
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
7
 * of the GNU General Public License version 2.
D
David Teigland 已提交
8 9 10 11 12 13
 */

#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

B
Bob Peterson 已提交
38 39 40
#define RSRV_CONTENTION_FACTOR 4
#define RGRP_RSRV_MAX_CONTENDERS 2

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

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

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

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

74 75
/**
 * gfs2_setbit - Set a bit in the bitmaps
76 77 78
 * @rgd: the resource group descriptor
 * @buf2: the clone buffer that holds the bitmaps
 * @bi: the bitmap structure
79 80 81 82 83
 * @block: the block to set
 * @new_state: the new state of the block
 *
 */

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

92 93
	byte1 = bi->bi_bh->b_data + bi->bi_offset + (block / GFS2_NBBY);
	end = bi->bi_bh->b_data + bi->bi_offset + buflen;
94

95
	BUG_ON(byte1 >= end);
96

97
	cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
98

99
	if (unlikely(!valid_change[new_state * 4 + cur_state])) {
100 101 102 103 104 105 106 107 108 109
		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();
110
		gfs2_consist_rgrpd(rgd);
111 112 113 114 115
		return;
	}
	*byte1 ^= (cur_state ^ new_state) << bit;

	if (buf2) {
116
		byte2 = buf2 + bi->bi_offset + (block / GFS2_NBBY);
117 118 119
		cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
		*byte2 ^= (cur_state ^ new_state) << bit;
	}
120 121 122 123
}

/**
 * gfs2_testbit - test a bit in the bitmaps
124
 * @rgd: the resource group descriptor
125 126 127 128 129 130
 * @buffer: the buffer that holds the bitmaps
 * @buflen: the length (in bytes) of the buffer
 * @block: the block to read
 *
 */

131 132 133
static inline unsigned char gfs2_testbit(struct gfs2_rgrpd *rgd,
					 const unsigned char *buffer,
					 unsigned int buflen, u32 block)
134
{
135 136
	const unsigned char *byte, *end;
	unsigned char cur_state;
137 138 139 140 141 142 143 144 145 146 147 148 149
	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;
}

150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
/**
 * 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[] = {
172 173 174 175
		[0] = 0xffffffffffffffffULL,
		[1] = 0xaaaaaaaaaaaaaaaaULL,
		[2] = 0x5555555555555555ULL,
		[3] = 0x0000000000000000ULL,
176 177 178 179 180 181 182
	};
	tmp = le64_to_cpu(*ptr) ^ search[state];
	tmp &= (tmp >> 1);
	tmp &= mask;
	return tmp;
}

B
Bob Peterson 已提交
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
/**
 * 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)
{
	u64 startblk = gfs2_rs_startblk(rs);

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

/**
 * rs_find - Find a rgrp multi-block reservation that contains a given block
 * @rgd: The rgrp
 * @rgblk: The block we're looking for, relative to the rgrp
 */
static struct gfs2_blkreserv *rs_find(struct gfs2_rgrpd *rgd, u32 rgblk)
{
	struct rb_node **newn;
	int rc;
	u64 fsblk = rgblk + rgd->rd_data0;

	spin_lock(&rgd->rd_rsspin);
	newn = &rgd->rd_rstree.rb_node;
	while (*newn) {
		struct gfs2_blkreserv *cur =
			rb_entry(*newn, struct gfs2_blkreserv, rs_node);
		rc = rs_cmp(fsblk, 1, cur);
		if (rc < 0)
			newn = &((*newn)->rb_left);
		else if (rc > 0)
			newn = &((*newn)->rb_right);
		else {
			spin_unlock(&rgd->rd_rsspin);
			return cur;
		}
	}
	spin_unlock(&rgd->rd_rsspin);
	return NULL;
}

234 235 236
/**
 * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
 *       a block in a given allocation state.
237
 * @buf: the buffer that holds the bitmaps
238
 * @len: the length (in bytes) of the buffer
239
 * @goal: start search at this block's bit-pair (within @buffer)
240
 * @state: GFS2_BLKST_XXX the state of the block we're looking for.
241 242 243
 *
 * 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
244 245 246 247 248
 * 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
249
 * always ok to read a complete multiple of 64 bits at the end
250
 * of the block in case the end is no aligned to a natural boundary.
251 252 253 254
 *
 * Return: the block number (bitmap buffer scope) that was found
 */

255 256
static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
		       u32 goal, u8 state)
257
{
258 259 260 261
	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;
262
	u64 mask = 0x5555555555555555ULL;
263 264 265 266 267 268 269 270 271
	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) {
272
		tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
273
		ptr++;
274
	}
275 276 277 278 279 280 281
	/* 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--;
282
	bit = __ffs64(tmp);
283 284
	bit /= 2;	/* two bits per entry in the bitmap */
	return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
285 286 287 288
}

/**
 * gfs2_bitcount - count the number of bits in a certain state
289
 * @rgd: the resource group descriptor
290 291 292 293 294 295 296
 * @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
 */

297 298
static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
			 unsigned int buflen, u8 state)
299
{
300 301 302 303 304
	const u8 *byte = buffer;
	const u8 *end = buffer + buflen;
	const u8 state1 = state << 2;
	const u8 state2 = state << 4;
	const u8 state3 = state << 6;
305
	u32 count = 0;
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320

	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 已提交
321 322 323 324 325 326 327 328 329 330
/**
 * 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;
331
	u32 length = rgd->rd_length;
332
	u32 count[4], tmp;
D
David Teigland 已提交
333 334
	int buf, x;

335
	memset(count, 0, 4 * sizeof(u32));
D
David Teigland 已提交
336 337 338 339 340 341 342 343 344 345 346

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

347
	if (count[0] != rgd->rd_free) {
D
David Teigland 已提交
348 349
		if (gfs2_consist_rgrpd(rgd))
			fs_err(sdp, "free data mismatch:  %u != %u\n",
350
			       count[0], rgd->rd_free);
D
David Teigland 已提交
351 352 353
		return;
	}

354
	tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
355
	if (count[1] != tmp) {
D
David Teigland 已提交
356 357 358 359 360 361
		if (gfs2_consist_rgrpd(rgd))
			fs_err(sdp, "used data mismatch:  %u != %u\n",
			       count[1], tmp);
		return;
	}

362
	if (count[2] + count[3] != rgd->rd_dinodes) {
D
David Teigland 已提交
363
		if (gfs2_consist_rgrpd(rgd))
364
			fs_err(sdp, "used metadata mismatch:  %u != %u\n",
365
			       count[2] + count[3], rgd->rd_dinodes);
D
David Teigland 已提交
366 367 368 369
		return;
	}
}

370
static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block)
D
David Teigland 已提交
371
{
372 373
	u64 first = rgd->rd_data0;
	u64 last = first + rgd->rd_data;
374
	return first <= block && block < last;
D
David Teigland 已提交
375 376 377 378 379
}

/**
 * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
 * @sdp: The GFS2 superblock
380 381
 * @blk: The data block number
 * @exact: True if this needs to be an exact match
D
David Teigland 已提交
382 383 384 385
 *
 * Returns: The resource group, or NULL if not found
 */

S
Steven Whitehouse 已提交
386
struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
D
David Teigland 已提交
387
{
S
Steven Whitehouse 已提交
388
	struct rb_node *n, *next;
389
	struct gfs2_rgrpd *cur;
D
David Teigland 已提交
390 391

	spin_lock(&sdp->sd_rindex_spin);
S
Steven Whitehouse 已提交
392 393 394 395
	n = sdp->sd_rindex_tree.rb_node;
	while (n) {
		cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
		next = NULL;
396
		if (blk < cur->rd_addr)
S
Steven Whitehouse 已提交
397
			next = n->rb_left;
398
		else if (blk >= cur->rd_data0 + cur->rd_data)
S
Steven Whitehouse 已提交
399 400
			next = n->rb_right;
		if (next == NULL) {
D
David Teigland 已提交
401
			spin_unlock(&sdp->sd_rindex_spin);
S
Steven Whitehouse 已提交
402 403 404 405 406 407
			if (exact) {
				if (blk < cur->rd_addr)
					return NULL;
				if (blk >= cur->rd_data0 + cur->rd_data)
					return NULL;
			}
408
			return cur;
D
David Teigland 已提交
409
		}
S
Steven Whitehouse 已提交
410
		n = next;
D
David Teigland 已提交
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
	}
	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)
{
426 427 428
	const struct rb_node *n;
	struct gfs2_rgrpd *rgd;

429
	spin_lock(&sdp->sd_rindex_spin);
430 431
	n = rb_first(&sdp->sd_rindex_tree);
	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
432
	spin_unlock(&sdp->sd_rindex_spin);
433 434

	return rgd;
D
David Teigland 已提交
435 436 437 438
}

/**
 * gfs2_rgrpd_get_next - get the next RG
439
 * @rgd: the resource group descriptor
D
David Teigland 已提交
440 441 442 443 444 445
 *
 * Returns: The next rgrp
 */

struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
{
446 447 448 449 450 451 452 453 454 455
	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 已提交
456
		return NULL;
457 458 459 460
	}
	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
	spin_unlock(&sdp->sd_rindex_spin);
	return rgd;
D
David Teigland 已提交
461 462
}

463 464 465 466 467 468 469 470 471 472 473
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;
	}
}

474 475 476 477 478 479 480
/**
 * 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)
{
	int error = 0;
B
Bob Peterson 已提交
481 482 483 484 485 486 487 488
	struct gfs2_blkreserv *res;

	if (ip->i_res)
		return 0;

	res = kmem_cache_zalloc(gfs2_rsrv_cachep, GFP_NOFS);
	if (!res)
		error = -ENOMEM;
489 490

	down_write(&ip->i_rw_mutex);
B
Bob Peterson 已提交
491 492 493 494
	if (ip->i_res)
		kmem_cache_free(gfs2_rsrv_cachep, res);
	else
		ip->i_res = res;
495 496 497 498
	up_write(&ip->i_rw_mutex);
	return error;
}

B
Bob Peterson 已提交
499 500 501 502 503 504 505
static void dump_rs(struct seq_file *seq, struct gfs2_blkreserv *rs)
{
	gfs2_print_dbg(seq, "  r: %llu s:%llu b:%u f:%u\n",
		       rs->rs_rgd->rd_addr, gfs2_rs_startblk(rs), rs->rs_biblk,
		       rs->rs_free);
}

506
/**
B
Bob Peterson 已提交
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
 * __rs_deltree - remove a multi-block reservation from the rgd tree
 * @rs: The reservation to remove
 *
 */
static void __rs_deltree(struct gfs2_blkreserv *rs)
{
	struct gfs2_rgrpd *rgd;

	if (!gfs2_rs_active(rs))
		return;

	rgd = rs->rs_rgd;
	/* We can't do this: The reason is that when the rgrp is invalidated,
	   it's in the "middle" of acquiring the glock, but the HOLDER bit
	   isn't set yet:
	   BUG_ON(!gfs2_glock_is_locked_by_me(rs->rs_rgd->rd_gl));*/
	trace_gfs2_rs(NULL, rs, TRACE_RS_TREEDEL);

	if (!RB_EMPTY_ROOT(&rgd->rd_rstree))
		rb_erase(&rs->rs_node, &rgd->rd_rstree);
	BUG_ON(!rgd->rd_rs_cnt);
	rgd->rd_rs_cnt--;

	if (rs->rs_free) {
		/* return reserved blocks to the rgrp and the ip */
		BUG_ON(rs->rs_rgd->rd_reserved < rs->rs_free);
		rs->rs_rgd->rd_reserved -= rs->rs_free;
		rs->rs_free = 0;
		clear_bit(GBF_FULL, &rs->rs_bi->bi_flags);
		smp_mb__after_clear_bit();
	}
	/* We can't change any of the step 1 or step 2 components of the rs.
	   E.g. We can't set rs_rgd to NULL because the rgd glock is held and
	   dequeued through this pointer.
	   Can't: atomic_set(&rs->rs_sizehint, 0);
	   Can't: rs->rs_rgd = NULL;*/
	rs->rs_bi = NULL;
	rs->rs_biblk = 0;
}

/**
 * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
 * @rs: The reservation to remove
 *
 */
void gfs2_rs_deltree(struct gfs2_blkreserv *rs)
{
	struct gfs2_rgrpd *rgd;

	if (!gfs2_rs_active(rs))
		return;

	rgd = rs->rs_rgd;
	spin_lock(&rgd->rd_rsspin);
	__rs_deltree(rs);
	spin_unlock(&rgd->rd_rsspin);
}

/**
 * gfs2_rs_delete - delete a multi-block reservation
567 568 569 570 571 572 573
 * @ip: The inode for this reservation
 *
 */
void gfs2_rs_delete(struct gfs2_inode *ip)
{
	down_write(&ip->i_rw_mutex);
	if (ip->i_res) {
B
Bob Peterson 已提交
574 575 576
		gfs2_rs_deltree(ip->i_res);
		trace_gfs2_rs(ip, ip->i_res, TRACE_RS_DELETE);
		BUG_ON(ip->i_res->rs_free);
577 578 579 580 581 582
		kmem_cache_free(gfs2_rsrv_cachep, ip->i_res);
		ip->i_res = NULL;
	}
	up_write(&ip->i_rw_mutex);
}

B
Bob Peterson 已提交
583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
/**
 * 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);
		__rs_deltree(rs);
	}
	spin_unlock(&rgd->rd_rsspin);
}

604
void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
D
David Teigland 已提交
605
{
606
	struct rb_node *n;
D
David Teigland 已提交
607 608 609
	struct gfs2_rgrpd *rgd;
	struct gfs2_glock *gl;

610 611
	while ((n = rb_first(&sdp->sd_rindex_tree))) {
		rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
D
David Teigland 已提交
612 613
		gl = rgd->rd_gl;

614
		rb_erase(n, &sdp->sd_rindex_tree);
D
David Teigland 已提交
615 616

		if (gl) {
617
			spin_lock(&gl->gl_spin);
618
			gl->gl_object = NULL;
619
			spin_unlock(&gl->gl_spin);
620
			gfs2_glock_add_to_lru(gl);
D
David Teigland 已提交
621 622 623
			gfs2_glock_put(gl);
		}

624
		gfs2_free_clones(rgd);
D
David Teigland 已提交
625
		kfree(rgd->rd_bits);
B
Bob Peterson 已提交
626
		return_all_reservations(rgd);
627
		kmem_cache_free(gfs2_rgrpd_cachep, rgd);
D
David Teigland 已提交
628 629 630
	}
}

631 632 633 634 635 636 637 638 639
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 已提交
640 641 642 643 644 645 646 647 648 649 650 651 652
/**
 * 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;
653
	u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
654
	u32 bytes_left, bytes;
D
David Teigland 已提交
655 656
	int x;

657 658 659
	if (!length)
		return -EINVAL;

660
	rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
D
David Teigland 已提交
661 662 663
	if (!rgd->rd_bits)
		return -ENOMEM;

664
	bytes_left = rgd->rd_bitbytes;
D
David Teigland 已提交
665 666 667 668

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

669
		bi->bi_flags = 0;
D
David Teigland 已提交
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
		/* 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);
686
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
D
David Teigland 已提交
687 688 689
			bi->bi_len = bytes;
		/* other blocks */
		} else {
690 691
			bytes = sdp->sd_sb.sb_bsize -
				sizeof(struct gfs2_meta_header);
D
David Teigland 已提交
692
			bi->bi_offset = sizeof(struct gfs2_meta_header);
693
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
D
David Teigland 已提交
694 695 696 697 698 699 700 701 702 703 704
			bi->bi_len = bytes;
		}

		bytes_left -= bytes;
	}

	if (bytes_left) {
		gfs2_consist_rgrpd(rgd);
		return -EIO;
	}
	bi = rgd->rd_bits + (length - 1);
705
	if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
D
David Teigland 已提交
706
		if (gfs2_consist_rgrpd(rgd)) {
707
			gfs2_rindex_print(rgd);
D
David Teigland 已提交
708 709 710 711 712 713 714 715 716
			fs_err(sdp, "start=%u len=%u offset=%u\n",
			       bi->bi_start, bi->bi_len, bi->bi_offset);
		}
		return -EIO;
	}

	return 0;
}

717 718
/**
 * gfs2_ri_total - Total up the file system space, according to the rindex.
719
 * @sdp: the filesystem
720 721 722 723 724 725 726 727 728 729 730 731 732
 *
 */
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);

733
		if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
734
			break;
735
		error = gfs2_internal_read(ip, buf, &pos,
736 737 738
					   sizeof(struct gfs2_rindex));
		if (error != sizeof(struct gfs2_rindex))
			break;
739
		total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
740 741 742 743
	}
	return total_data;
}

B
Bob Peterson 已提交
744
static int rgd_insert(struct gfs2_rgrpd *rgd)
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
{
	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 已提交
760
			return -EEXIST;
761 762 763 764
	}

	rb_link_node(&rgd->rd_node, parent, newn);
	rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
B
Bob Peterson 已提交
765 766
	sdp->sd_rgrps++;
	return 0;
767 768
}

D
David Teigland 已提交
769
/**
770
 * read_rindex_entry - Pull in a new resource index entry from the disk
771
 * @ip: Pointer to the rindex inode
D
David Teigland 已提交
772
 *
773
 * Returns: 0 on success, > 0 on EOF, error code otherwise
774 775
 */

776
static int read_rindex_entry(struct gfs2_inode *ip)
777 778 779
{
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
780
	struct gfs2_rindex buf;
781 782 783
	int error;
	struct gfs2_rgrpd *rgd;

784 785 786
	if (pos >= i_size_read(&ip->i_inode))
		return 1;

787
	error = gfs2_internal_read(ip, (char *)&buf, &pos,
788
				   sizeof(struct gfs2_rindex));
789 790 791

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

793
	rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
794 795 796 797 798
	error = -ENOMEM;
	if (!rgd)
		return error;

	rgd->rd_sbd = sdp;
799 800 801 802 803
	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 已提交
804
	spin_lock_init(&rgd->rd_rsspin);
805

806 807
	error = compute_bitstructs(rgd);
	if (error)
808
		goto fail;
809

810
	error = gfs2_glock_get(sdp, rgd->rd_addr,
811 812
			       &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
	if (error)
813
		goto fail;
814 815

	rgd->rd_gl->gl_object = rgd;
816
	rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lvb;
817
	rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
818 819
	if (rgd->rd_data > sdp->sd_max_rg_data)
		sdp->sd_max_rg_data = rgd->rd_data;
820
	spin_lock(&sdp->sd_rindex_spin);
B
Bob Peterson 已提交
821
	error = rgd_insert(rgd);
822
	spin_unlock(&sdp->sd_rindex_spin);
B
Bob Peterson 已提交
823 824 825 826
	if (!error)
		return 0;

	error = 0; /* someone else read in the rgrp; free it and ignore it */
827
	gfs2_glock_put(rgd->rd_gl);
828 829 830 831

fail:
	kfree(rgd->rd_bits);
	kmem_cache_free(gfs2_rgrpd_cachep, rgd);
832 833 834 835 836 837 838
	return error;
}

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

842
static int gfs2_ri_update(struct gfs2_inode *ip)
D
David Teigland 已提交
843
{
844
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
845 846
	int error;

847
	do {
848
		error = read_rindex_entry(ip);
849 850 851 852
	} while (error == 0);

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

854
	sdp->sd_rindex_uptodate = 1;
855 856
	return 0;
}
D
David Teigland 已提交
857 858

/**
859
 * gfs2_rindex_update - Update the rindex if required
D
David Teigland 已提交
860 861 862 863 864 865 866 867 868 869 870 871
 * @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.
 *
872
 * Returns: 0 on succeess, error code otherwise
D
David Teigland 已提交
873 874
 */

875
int gfs2_rindex_update(struct gfs2_sbd *sdp)
D
David Teigland 已提交
876
{
877
	struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
D
David Teigland 已提交
878
	struct gfs2_glock *gl = ip->i_gl;
879 880
	struct gfs2_holder ri_gh;
	int error = 0;
881
	int unlock_required = 0;
D
David Teigland 已提交
882 883

	/* Read new copy from disk if we don't have the latest */
884
	if (!sdp->sd_rindex_uptodate) {
885 886 887
		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 已提交
888
				return error;
889 890
			unlock_required = 1;
		}
891
		if (!sdp->sd_rindex_uptodate)
D
David Teigland 已提交
892
			error = gfs2_ri_update(ip);
893 894
		if (unlock_required)
			gfs2_glock_dq_uninit(&ri_gh);
D
David Teigland 已提交
895 896 897 898 899
	}

	return error;
}

900
static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
901 902
{
	const struct gfs2_rgrp *str = buf;
903
	u32 rg_flags;
904

905
	rg_flags = be32_to_cpu(str->rg_flags);
906
	rg_flags &= ~GFS2_RDF_MASK;
907 908
	rgd->rd_flags &= GFS2_RDF_MASK;
	rgd->rd_flags |= rg_flags;
909
	rgd->rd_free = be32_to_cpu(str->rg_free);
910
	rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
911
	rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
912 913
}

914
static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
915 916 917
{
	struct gfs2_rgrp *str = buf;

918
	str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
919
	str->rg_free = cpu_to_be32(rgd->rd_free);
920
	str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
921
	str->__pad = cpu_to_be32(0);
922
	str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
923 924 925
	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
}

926 927 928 929 930 931 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 977 978 979 980 981
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 已提交
982
/**
983 984
 * 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 已提交
985 986 987 988 989 990 991
 *
 * 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
 */

992
int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
D
David Teigland 已提交
993 994 995
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct gfs2_glock *gl = rgd->rd_gl;
996
	unsigned int length = rgd->rd_length;
D
David Teigland 已提交
997 998 999 1000
	struct gfs2_bitmap *bi;
	unsigned int x, y;
	int error;

1001 1002 1003
	if (rgd->rd_bits[0].bi_bh != NULL)
		return 0;

D
David Teigland 已提交
1004 1005
	for (x = 0; x < length; x++) {
		bi = rgd->rd_bits + x;
1006
		error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
D
David Teigland 已提交
1007 1008 1009 1010 1011 1012
		if (error)
			goto fail;
	}

	for (y = length; y--;) {
		bi = rgd->rd_bits + y;
S
Steven Whitehouse 已提交
1013
		error = gfs2_meta_wait(sdp, bi->bi_bh);
D
David Teigland 已提交
1014 1015
		if (error)
			goto fail;
1016
		if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
D
David Teigland 已提交
1017 1018 1019 1020 1021 1022
					      GFS2_METATYPE_RG)) {
			error = -EIO;
			goto fail;
		}
	}

1023
	if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
1024 1025
		for (x = 0; x < length; x++)
			clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
1026
		gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
1027
		rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
1028
		rgd->rd_free_clone = rgd->rd_free;
D
David Teigland 已提交
1029
	}
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
	if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
		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 已提交
1044 1045
	return 0;

1046
fail:
D
David Teigland 已提交
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
	while (x--) {
		bi = rgd->rd_bits + x;
		brelse(bi->bi_bh);
		bi->bi_bh = NULL;
		gfs2_assert_warn(sdp, !bi->bi_clone);
	}

	return error;
}

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 1088 1089
int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
{
	u32 rl_flags;

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

	if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
		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 已提交
1090
/**
1091
 * gfs2_rgrp_go_unlock - Release RG bitmaps read in with gfs2_rgrp_bh_get()
1092
 * @gh: The glock holder for the resource group
D
David Teigland 已提交
1093 1094 1095
 *
 */

1096
void gfs2_rgrp_go_unlock(struct gfs2_holder *gh)
D
David Teigland 已提交
1097
{
1098
	struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1099
	int x, length = rgd->rd_length;
D
David Teigland 已提交
1100 1101 1102

	for (x = 0; x < length; x++) {
		struct gfs2_bitmap *bi = rgd->rd_bits + x;
1103 1104 1105 1106
		if (bi->bi_bh) {
			brelse(bi->bi_bh);
			bi->bi_bh = NULL;
		}
D
David Teigland 已提交
1107 1108 1109 1110
	}

}

S
Steven Whitehouse 已提交
1111
int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
1112
			     struct buffer_head *bh,
S
Steven Whitehouse 已提交
1113
			     const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
1114 1115 1116 1117
{
	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 /
1118
					   bdev_logical_block_size(sb->s_bdev);
1119
	u64 blk;
1120
	sector_t start = 0;
1121 1122 1123
	sector_t nr_sects = 0;
	int rv;
	unsigned int x;
S
Steven Whitehouse 已提交
1124 1125
	u32 trimmed = 0;
	u8 diff;
1126 1127

	for (x = 0; x < bi->bi_len; x++) {
S
Steven Whitehouse 已提交
1128 1129 1130 1131 1132 1133 1134 1135 1136
		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));
		}
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
		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 已提交
1147 1148 1149 1150 1151 1152 1153 1154
					if (nr_sects >= minlen) {
						rv = blkdev_issue_discard(bdev,
							start, nr_sects,
							GFP_NOFS, 0);
						if (rv)
							goto fail;
						trimmed += nr_sects;
					}
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
					nr_sects = 0;
start_new_extent:
					start = blk;
				}
				nr_sects += sects_per_blk;
			}
			diff >>= 2;
			blk += sects_per_blk;
		}
	}
S
Steven Whitehouse 已提交
1165
	if (nr_sects >= minlen) {
1166
		rv = blkdev_issue_discard(bdev, start, nr_sects, GFP_NOFS, 0);
1167 1168
		if (rv)
			goto fail;
S
Steven Whitehouse 已提交
1169
		trimmed += nr_sects;
1170
	}
S
Steven Whitehouse 已提交
1171 1172 1173 1174
	if (ptrimmed)
		*ptrimmed = trimmed;
	return 0;

1175
fail:
S
Steven Whitehouse 已提交
1176 1177
	if (sdp->sd_args.ar_discard)
		fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem", rv);
1178
	sdp->sd_args.ar_discard = 0;
S
Steven Whitehouse 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
	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;

1218 1219 1220 1221
	ret = gfs2_rindex_update(sdp);
	if (ret)
		return ret;

S
Steven Whitehouse 已提交
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
	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);
1250
				gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, bh->b_data);
S
Steven Whitehouse 已提交
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
				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;
1268 1269
}

B
Bob Peterson 已提交
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
/**
 * rs_insert - insert a new multi-block reservation into the rgrp's rb_tree
 * @bi: the bitmap with the blocks
 * @ip: the inode structure
 * @biblk: the 32-bit block number relative to the start of the bitmap
 * @amount: the number of blocks to reserve
 *
 * Returns: NULL - reservation was already taken, so not inserted
 *          pointer to the inserted reservation
 */
static struct gfs2_blkreserv *rs_insert(struct gfs2_bitmap *bi,
				       struct gfs2_inode *ip, u32 biblk,
				       int amount)
{
	struct rb_node **newn, *parent = NULL;
	int rc;
	struct gfs2_blkreserv *rs = ip->i_res;
	struct gfs2_rgrpd *rgd = rs->rs_rgd;
	u64 fsblock = gfs2_bi2rgd_blk(bi, biblk) + rgd->rd_data0;

	spin_lock(&rgd->rd_rsspin);
	newn = &rgd->rd_rstree.rb_node;
	BUG_ON(!ip->i_res);
	BUG_ON(gfs2_rs_active(rs));
	/* Figure out where to put new node */
	/*BUG_ON(!gfs2_glock_is_locked_by_me(rgd->rd_gl));*/
	while (*newn) {
		struct gfs2_blkreserv *cur =
			rb_entry(*newn, struct gfs2_blkreserv, rs_node);

		parent = *newn;
		rc = rs_cmp(fsblock, amount, cur);
		if (rc > 0)
			newn = &((*newn)->rb_right);
		else if (rc < 0)
			newn = &((*newn)->rb_left);
		else {
			spin_unlock(&rgd->rd_rsspin);
			return NULL; /* reservation already in use */
		}
	}

	/* Do our reservation work */
	rs = ip->i_res;
	rs->rs_free = amount;
	rs->rs_biblk = biblk;
	rs->rs_bi = bi;
	rb_link_node(&rs->rs_node, parent, newn);
	rb_insert_color(&rs->rs_node, &rgd->rd_rstree);

	/* Do our inode accounting for the reservation */
	/*BUG_ON(!gfs2_glock_is_locked_by_me(ip->i_gl));*/

	/* Do our rgrp accounting for the reservation */
	rgd->rd_reserved += amount; /* blocks reserved */
	rgd->rd_rs_cnt++; /* number of in-tree reservations */
	spin_unlock(&rgd->rd_rsspin);
	trace_gfs2_rs(ip, rs, TRACE_RS_INSERT);
	return rs;
}

/**
 * unclaimed_blocks - return number of blocks that aren't spoken for
 */
static u32 unclaimed_blocks(struct gfs2_rgrpd *rgd)
{
	return rgd->rd_free_clone - rgd->rd_reserved;
}

/**
 * rg_mblk_search - find a group of multiple free blocks
 * @rgd: the resource group descriptor
 * @rs: the block reservation
 * @ip: pointer to the inode for which we're reserving blocks
 *
 * This is very similar to rgblk_search, except we're looking for whole
 * 64-bit words that represent a chunk of 32 free blocks. I'm only focusing
 * on aligned dwords for speed's sake.
 *
 * Returns: 0 if successful or BFITNOENT if there isn't enough free space
 */

1352
static int rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip, unsigned requested)
B
Bob Peterson 已提交
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
{
	struct gfs2_bitmap *bi = rgd->rd_bits;
	const u32 length = rgd->rd_length;
	u32 blk;
	unsigned int buf, x, search_bytes;
	u8 *buffer = NULL;
	u8 *ptr, *end, *nonzero;
	u32 goal, rsv_bytes;
	struct gfs2_blkreserv *rs;
	u32 best_rs_bytes, unclaimed;
	int best_rs_blocks;

	/* Find bitmap block that contains bits for goal block */
	if (rgrp_contains_block(rgd, ip->i_goal))
		goal = ip->i_goal - rgd->rd_data0;
	else
		goal = rgd->rd_last_alloc;
	for (buf = 0; buf < length; buf++) {
		bi = rgd->rd_bits + buf;
		/* 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;
		}
	}
	buf = 0;
	goal = 0;

do_search:
	best_rs_blocks = max_t(int, atomic_read(&ip->i_res->rs_sizehint),
			       (RGRP_RSRV_MINBLKS * rgd->rd_length));
	best_rs_bytes = (best_rs_blocks *
			 (1 + (RSRV_CONTENTION_FACTOR * rgd->rd_rs_cnt))) /
		GFS2_NBBY; /* 1 + is for our not-yet-created reservation */
	best_rs_bytes = ALIGN(best_rs_bytes, sizeof(u64));
	unclaimed = unclaimed_blocks(rgd);
	if (best_rs_bytes * GFS2_NBBY > unclaimed)
		best_rs_bytes = unclaimed >> GFS2_BIT_SIZE;

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

		if (test_bit(GBF_FULL, &bi->bi_flags))
			goto skip;

		WARN_ON(!buffer_uptodate(bi->bi_bh));
		if (bi->bi_clone)
			buffer = bi->bi_clone + bi->bi_offset;
		else
			buffer = bi->bi_bh->b_data + bi->bi_offset;

		/* We have to keep the reservations aligned on u64 boundaries
		   otherwise we could get situations where a byte can't be
		   used because it's after a reservation, but a free bit still
		   is within the reservation's area. */
		ptr = buffer + ALIGN(goal >> GFS2_BIT_SIZE, sizeof(u64));
		end = (buffer + bi->bi_len);
		while (ptr < end) {
			rsv_bytes = 0;
			if ((ptr + best_rs_bytes) <= end)
				search_bytes = best_rs_bytes;
			else
				search_bytes = end - ptr;
			BUG_ON(!search_bytes);
			nonzero = memchr_inv(ptr, 0, search_bytes);
			/* If the lot is all zeroes, reserve the whole size. If
			   there's enough zeroes to satisfy the request, use
			   what we can. If there's not enough, keep looking. */
			if (nonzero == NULL)
				rsv_bytes = search_bytes;
1424
			else if ((nonzero - ptr) * GFS2_NBBY >= requested)
B
Bob Peterson 已提交
1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449
				rsv_bytes = (nonzero - ptr);

			if (rsv_bytes) {
				blk = ((ptr - buffer) * GFS2_NBBY);
				BUG_ON(blk >= bi->bi_len * GFS2_NBBY);
				rs = rs_insert(bi, ip, blk,
					       rsv_bytes * GFS2_NBBY);
				if (IS_ERR(rs))
					return PTR_ERR(rs);
				if (rs)
					return 0;
			}
			ptr += ALIGN(search_bytes, sizeof(u64));
		}
skip:
		/* Try next bitmap block (wrap back to rgrp header
		   if at end) */
		buf++;
		buf %= length;
		goal = 0;
	}

	return BFITNOENT;
}

D
David Teigland 已提交
1450 1451 1452
/**
 * try_rgrp_fit - See if a given reservation will fit in a given RG
 * @rgd: the RG data
1453
 * @ip: the inode
D
David Teigland 已提交
1454 1455
 *
 * If there's room for the requested blocks to be allocated from the RG:
B
Bob Peterson 已提交
1456 1457
 * This will try to get a multi-block reservation first, and if that doesn't
 * fit, it will take what it can.
D
David Teigland 已提交
1458 1459 1460 1461
 *
 * Returns: 1 on success (it fits), 0 on failure (it doesn't fit)
 */

1462 1463
static int try_rgrp_fit(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
			unsigned requested)
D
David Teigland 已提交
1464
{
1465
	if (rgd->rd_flags & (GFS2_RGF_NOALLOC | GFS2_RDF_ERROR))
1466
		return 0;
B
Bob Peterson 已提交
1467 1468
	/* Look for a multi-block reservation. */
	if (unclaimed_blocks(rgd) >= RGRP_RSRV_MINBLKS &&
1469
	    rg_mblk_search(rgd, ip, requested) != BFITNOENT)
B
Bob Peterson 已提交
1470
		return 1;
1471
	if (unclaimed_blocks(rgd) >= requested)
1472
		return 1;
D
David Teigland 已提交
1473

B
Bob Peterson 已提交
1474
	return 0;
B
Bob Peterson 已提交
1475 1476
}

1477 1478 1479
/**
 * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
 * @rgd: The rgrp
1480 1481
 * @last_unlinked: block address of the last dinode we unlinked
 * @skip: block address we should explicitly not unlink
1482
 *
B
Bob Peterson 已提交
1483 1484
 * Returns: 0 if no error
 *          The inode, if one has been found, in inode.
1485 1486
 */

1487
static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
1488
{
1489
	u32 goal = 0, block;
1490
	u64 no_addr;
1491
	struct gfs2_sbd *sdp = rgd->rd_sbd;
1492 1493 1494 1495
	struct gfs2_glock *gl;
	struct gfs2_inode *ip;
	int error;
	int found = 0;
B
Bob Peterson 已提交
1496
	struct gfs2_bitmap *bi;
1497

1498
	while (goal < rgd->rd_data) {
1499
		down_write(&sdp->sd_log_flush_lock);
1500
		block = rgblk_search(rgd, goal, GFS2_BLKST_UNLINKED, &bi);
1501
		up_write(&sdp->sd_log_flush_lock);
1502
		if (block == BFITNOENT)
1503
			break;
B
Bob Peterson 已提交
1504 1505

		block = gfs2_bi2rgd_blk(bi, block);
1506 1507 1508
		/* rgblk_search can return a block < goal, so we need to
		   keep it marching forward. */
		no_addr = block + rgd->rd_data0;
1509
		goal = max(block + 1, goal + 1);
1510
		if (*last_unlinked != NO_BLOCK && no_addr <= *last_unlinked)
1511
			continue;
1512 1513
		if (no_addr == skip)
			continue;
1514
		*last_unlinked = no_addr;
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534

		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 */
1535
		if (found > NR_CPUS)
1536
			return;
1537 1538 1539
	}

	rgd->rd_flags &= ~GFS2_RDF_CHECK;
1540
	return;
1541 1542
}

D
David Teigland 已提交
1543
/**
1544
 * gfs2_inplace_reserve - Reserve space in the filesystem
D
David Teigland 已提交
1545
 * @ip: the inode to reserve space for
1546
 * @requested: the number of blocks to be reserved
D
David Teigland 已提交
1547 1548 1549 1550
 *
 * Returns: errno
 */

1551
int gfs2_inplace_reserve(struct gfs2_inode *ip, u32 requested)
D
David Teigland 已提交
1552
{
1553
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
B
Bob Peterson 已提交
1554
	struct gfs2_rgrpd *begin = NULL;
1555
	struct gfs2_blkreserv *rs = ip->i_res;
1556 1557
	int error = 0, rg_locked, flags = LM_FLAG_TRY;
	u64 last_unlinked = NO_BLOCK;
1558
	int loops = 0;
D
David Teigland 已提交
1559

1560 1561
	if (sdp->sd_args.ar_rgrplvb)
		flags |= GL_SKIP;
1562 1563 1564 1565
	if (gfs2_assert_warn(sdp, requested)) {
		error = -EINVAL;
		goto out;
	}
B
Bob Peterson 已提交
1566 1567 1568 1569 1570 1571 1572 1573 1574
	if (gfs2_rs_active(rs)) {
		begin = rs->rs_rgd;
		flags = 0; /* Yoda: Do or do not. There is no try */
	} else if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, ip->i_goal)) {
		rs->rs_rgd = begin = ip->i_rgd;
	} else {
		rs->rs_rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
	}
	if (rs->rs_rgd == NULL)
1575 1576 1577
		return -EBADSLT;

	while (loops < 3) {
1578 1579
		rg_locked = 0;

B
Bob Peterson 已提交
1580
		if (gfs2_glock_is_locked_by_me(rs->rs_rgd->rd_gl)) {
1581 1582
			rg_locked = 1;
			error = 0;
B
Bob Peterson 已提交
1583 1584 1585 1586 1587 1588
		} else if (!loops && !gfs2_rs_active(rs) &&
			   rs->rs_rgd->rd_rs_cnt > RGRP_RSRV_MAX_CONTENDERS) {
			/* If the rgrp already is maxed out for contenders,
			   we can eliminate it as a "first pass" without even
			   requesting the rgrp glock. */
			error = GLR_TRYFAILED;
1589
		} else {
B
Bob Peterson 已提交
1590 1591 1592
			error = gfs2_glock_nq_init(rs->rs_rgd->rd_gl,
						   LM_ST_EXCLUSIVE, flags,
						   &rs->rs_rgd_gh);
1593
			if (!error && sdp->sd_args.ar_rgrplvb) {
B
Bob Peterson 已提交
1594
				error = update_rgrp_lvb(rs->rs_rgd);
1595 1596 1597 1598 1599
				if (error) {
					gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
					return error;
				}
			}
1600
		}
D
David Teigland 已提交
1601 1602
		switch (error) {
		case 0:
B
Bob Peterson 已提交
1603 1604
			if (gfs2_rs_active(rs)) {
				if (unclaimed_blocks(rs->rs_rgd) +
1605
				    rs->rs_free >= requested) {
B
Bob Peterson 已提交
1606 1607 1608 1609 1610 1611 1612 1613 1614
					ip->i_rgd = rs->rs_rgd;
					return 0;
				}
				/* We have a multi-block reservation, but the
				   rgrp doesn't have enough free blocks to
				   satisfy the request. Free the reservation
				   and look for a suitable rgrp. */
				gfs2_rs_deltree(rs);
			}
1615
			if (try_rgrp_fit(rs->rs_rgd, ip, requested)) {
1616
				if (sdp->sd_args.ar_rgrplvb)
B
Bob Peterson 已提交
1617 1618
					gfs2_rgrp_bh_get(rs->rs_rgd);
				ip->i_rgd = rs->rs_rgd;
1619
				return 0;
1620
			}
B
Bob Peterson 已提交
1621
			if (rs->rs_rgd->rd_flags & GFS2_RDF_CHECK) {
1622
				if (sdp->sd_args.ar_rgrplvb)
B
Bob Peterson 已提交
1623 1624
					gfs2_rgrp_bh_get(rs->rs_rgd);
				try_rgrp_unlink(rs->rs_rgd, &last_unlinked,
1625
						ip->i_no_addr);
1626
			}
1627
			if (!rg_locked)
1628
				gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1629
			/* fall through */
D
David Teigland 已提交
1630
		case GLR_TRYFAILED:
B
Bob Peterson 已提交
1631 1632 1633
			rs->rs_rgd = gfs2_rgrpd_get_next(rs->rs_rgd);
			rs->rs_rgd = rs->rs_rgd ? : begin; /* if NULL, wrap */
			if (rs->rs_rgd != begin) /* If we didn't wrap */
1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
				break;

			flags &= ~LM_FLAG_TRY;
			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)
					goto out;
			} else if (loops == 2)
				/* Flushing the log may release space */
				gfs2_log_flush(sdp, NULL);
D
David Teigland 已提交
1647 1648
			break;
		default:
1649
			goto out;
D
David Teigland 已提交
1650 1651
		}
	}
1652
	error = -ENOSPC;
D
David Teigland 已提交
1653

1654
out:
1655
	return error;
D
David Teigland 已提交
1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
}

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

1669 1670
	if (rs->rs_rgd_gh.gh_gl)
		gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
D
David Teigland 已提交
1671 1672 1673 1674 1675 1676 1677 1678 1679 1680
}

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

1681
static unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
D
David Teigland 已提交
1682 1683
{
	struct gfs2_bitmap *bi = NULL;
1684
	u32 length, rgrp_block, buf_block;
D
David Teigland 已提交
1685 1686 1687
	unsigned int buf;
	unsigned char type;

1688 1689
	length = rgd->rd_length;
	rgrp_block = block - rgd->rd_data0;
D
David Teigland 已提交
1690 1691 1692 1693 1694 1695 1696 1697 1698 1699

	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;

1700
	type = gfs2_testbit(rgd, bi->bi_bh->b_data + bi->bi_offset,
D
David Teigland 已提交
1701 1702 1703 1704 1705 1706
			   bi->bi_len, buf_block);

	return type;
}

/**
1707
 * rgblk_search - find a block in @state
D
David Teigland 已提交
1708 1709
 * @rgd: the resource group descriptor
 * @goal: the goal block within the RG (start here to search for avail block)
1710
 * @state: GFS2_BLKST_XXX the before-allocation state to find
B
Bob Peterson 已提交
1711
 * @rbi: address of the pointer to the bitmap containing the block found
D
David Teigland 已提交
1712
 *
1713
 * Walk rgrp's bitmap to find bits that represent a block in @state.
D
David Teigland 已提交
1714 1715 1716 1717
 *
 * 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 已提交
1718 1719
 * 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 已提交
1720
 *
B
Bob Peterson 已提交
1721
 * Returns: the block number found relative to the bitmap rbi
D
David Teigland 已提交
1722 1723
 */

1724
static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal, unsigned char state,
B
Bob Peterson 已提交
1725
			struct gfs2_bitmap **rbi)
D
David Teigland 已提交
1726 1727
{
	struct gfs2_bitmap *bi = NULL;
1728
	const u32 length = rgd->rd_length;
1729
	u32 biblk = BFITNOENT;
D
David Teigland 已提交
1730
	unsigned int buf, x;
1731
	const u8 *buffer = NULL;
D
David Teigland 已提交
1732

B
Bob Peterson 已提交
1733
	*rbi = NULL;
D
David Teigland 已提交
1734 1735 1736
	/* Find bitmap block that contains bits for goal block */
	for (buf = 0; buf < length; buf++) {
		bi = rgd->rd_bits + buf;
1737 1738 1739 1740 1741
		/* 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 已提交
1742
	}
1743 1744
	buf = 0;
	goal = 0;
D
David Teigland 已提交
1745

1746
do_search:
D
David Teigland 已提交
1747 1748 1749 1750 1751 1752
	/* 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++) {
1753 1754 1755
		bi = rgd->rd_bits + buf;

		if (test_bit(GBF_FULL, &bi->bi_flags) &&
1756
		    (state == GFS2_BLKST_FREE))
1757 1758
			goto skip;

1759 1760
		/* The GFS2_BLKST_UNLINKED state doesn't apply to the clone
		   bitmaps, so we must search the originals for that. */
1761
		buffer = bi->bi_bh->b_data + bi->bi_offset;
1762
		WARN_ON(!buffer_uptodate(bi->bi_bh));
1763
		if (state != GFS2_BLKST_UNLINKED && bi->bi_clone)
1764 1765
			buffer = bi->bi_clone + bi->bi_offset;

B
Bob Peterson 已提交
1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786
		while (1) {
			struct gfs2_blkreserv *rs;
			u32 rgblk;

			biblk = gfs2_bitfit(buffer, bi->bi_len, goal, state);
			if (biblk == BFITNOENT)
				break;
			/* Check if this block is reserved() */
			rgblk = gfs2_bi2rgd_blk(bi, biblk);
			rs = rs_find(rgd, rgblk);
			if (rs == NULL)
				break;

			BUG_ON(rs->rs_bi != bi);
			biblk = BFITNOENT;
			/* This should jump to the first block after the
			   reservation. */
			goal = rs->rs_biblk + rs->rs_free;
			if (goal >= bi->bi_len * GFS2_NBBY)
				break;
		}
1787
		if (biblk != BFITNOENT)
D
David Teigland 已提交
1788 1789
			break;

1790
		if ((goal == 0) && (state == GFS2_BLKST_FREE))
1791 1792
			set_bit(GBF_FULL, &bi->bi_flags);

D
David Teigland 已提交
1793
		/* Try next bitmap block (wrap back to rgrp header if at end) */
1794 1795 1796
skip:
		buf++;
		buf %= length;
D
David Teigland 已提交
1797 1798 1799
		goal = 0;
	}

1800
	if (biblk != BFITNOENT)
B
Bob Peterson 已提交
1801
		*rbi = bi;
1802

1803
	return biblk;
B
Bob Peterson 已提交
1804
}
1805

B
Bob Peterson 已提交
1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
/**
 * 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;
B
Bob Peterson 已提交
1822
	u32 goal, rgblk;
B
Bob Peterson 已提交
1823
	const u8 *buffer = NULL;
B
Bob Peterson 已提交
1824
	struct gfs2_blkreserv *rs;
B
Bob Peterson 已提交
1825

1826
	*n = 0;
B
Bob Peterson 已提交
1827
	buffer = bi->bi_bh->b_data + bi->bi_offset;
1828
	gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
1829 1830
	gfs2_setbit(rgd, bi->bi_clone, bi, blk,
		    dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
1831
	(*n)++;
1832 1833 1834 1835 1836
	goal = blk;
	while (*n < elen) {
		goal++;
		if (goal >= (bi->bi_len * GFS2_NBBY))
			break;
B
Bob Peterson 已提交
1837 1838 1839 1840
		rgblk = gfs2_bi2rgd_blk(bi, goal);
		rs = rs_find(rgd, rgblk);
		if (rs) /* Oops, we bumped into someone's reservation */
			break;
1841 1842 1843
		if (gfs2_testbit(rgd, buffer, bi->bi_len, goal) !=
		    GFS2_BLKST_FREE)
			break;
1844
		gfs2_setbit(rgd, bi->bi_clone, bi, goal, GFS2_BLKST_USED);
1845
		(*n)++;
1846
	}
B
Bob Peterson 已提交
1847
	blk = gfs2_bi2rgd_blk(bi, blk);
1848
	rgd->rd_last_alloc = blk + *n - 1;
B
Bob Peterson 已提交
1849
	return rgd->rd_data0 + blk;
D
David Teigland 已提交
1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861
}

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

1862 1863
static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
				     u32 blen, unsigned char new_state)
D
David Teigland 已提交
1864 1865 1866
{
	struct gfs2_rgrpd *rgd;
	struct gfs2_bitmap *bi = NULL;
1867
	u32 length, rgrp_blk, buf_blk;
D
David Teigland 已提交
1868 1869
	unsigned int buf;

S
Steven Whitehouse 已提交
1870
	rgd = gfs2_blk2rgrpd(sdp, bstart, 1);
D
David Teigland 已提交
1871 1872
	if (!rgd) {
		if (gfs2_consist(sdp))
1873
			fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);
D
David Teigland 已提交
1874 1875 1876
		return NULL;
	}

1877
	length = rgd->rd_length;
D
David Teigland 已提交
1878

1879
	rgrp_blk = bstart - rgd->rd_data0;
D
David Teigland 已提交
1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894

	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,
1895
					       GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
1896 1897 1898 1899
			memcpy(bi->bi_clone + bi->bi_offset,
			       bi->bi_bh->b_data + bi->bi_offset,
			       bi->bi_len);
		}
1900
		gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
1901
		gfs2_setbit(rgd, NULL, bi, buf_blk, new_state);
D
David Teigland 已提交
1902 1903 1904 1905 1906 1907
	}

	return rgd;
}

/**
1908 1909 1910 1911 1912 1913 1914 1915
 * 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 已提交
1916 1917 1918 1919
	struct gfs2_rgrpd *rgd = gl->gl_object;
	struct gfs2_blkreserv *trs;
	const struct rb_node *n;

1920 1921
	if (rgd == NULL)
		return 0;
B
Bob Peterson 已提交
1922
	gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u r:%u\n",
1923
		       (unsigned long long)rgd->rd_addr, rgd->rd_flags,
B
Bob Peterson 已提交
1924 1925 1926 1927 1928 1929 1930 1931
		       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);
1932 1933 1934
	return 0;
}

1935 1936 1937 1938
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 已提交
1939
		(unsigned long long)rgd->rd_addr);
1940 1941 1942 1943 1944
	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 已提交
1945 1946 1947 1948 1949 1950
/**
 * claim_reserved_blks - Claim previously reserved blocks
 * @ip: the inode that's claiming the reservation
 * @dinode: 1 if this block is a dinode block, otherwise data block
 * @nblocks: desired extent length
 *
1951
 * Lay claim to previously reserved blocks.
B
Bob Peterson 已提交
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967
 * Returns: Starting block number of the blocks claimed.
 * Sets *nblocks to the actual extent length allocated.
 */
static u64 claim_reserved_blks(struct gfs2_inode *ip, bool dinode,
			       unsigned int *nblocks)
{
	struct gfs2_blkreserv *rs = ip->i_res;
	struct gfs2_rgrpd *rgd = rs->rs_rgd;
	struct gfs2_bitmap *bi;
	u64 start_block = gfs2_rs_startblk(rs);
	const unsigned int elen = *nblocks;

	bi = rs->rs_bi;
	gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);

	for (*nblocks = 0; *nblocks < elen && rs->rs_free; (*nblocks)++) {
1968 1969 1970
		if (gfs2_testbit(rgd, bi->bi_bh->b_data + bi->bi_offset,
				 bi->bi_len, rs->rs_biblk) != GFS2_BLKST_FREE)
			break;
B
Bob Peterson 已提交
1971 1972 1973 1974 1975 1976 1977 1978 1979 1980
		gfs2_setbit(rgd, bi->bi_clone, bi, rs->rs_biblk,
			    dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
		rs->rs_biblk++;
		rs->rs_free--;

		BUG_ON(!rgd->rd_reserved);
		rgd->rd_reserved--;
		dinode = false;
	}

1981 1982
	trace_gfs2_rs(ip, rs, TRACE_RS_CLAIM);
	if (!rs->rs_free || *nblocks != elen)
B
Bob Peterson 已提交
1983
		gfs2_rs_deltree(rs);
1984

B
Bob Peterson 已提交
1985 1986 1987
	return start_block;
}

1988
/**
1989
 * gfs2_alloc_blocks - Allocate one or more blocks of data and/or a dinode
1990
 * @ip: the inode to allocate the block for
1991
 * @bn: Used to return the starting block number
B
Bob Peterson 已提交
1992
 * @nblocks: requested number of blocks/extent length (value/result)
1993
 * @dinode: 1 if we're allocating a dinode block, else 0
1994
 * @generation: the generation number of the inode
D
David Teigland 已提交
1995
 *
1996
 * Returns: 0 or error
D
David Teigland 已提交
1997 1998
 */

1999
int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
2000
		      bool dinode, u64 *generation)
D
David Teigland 已提交
2001
{
2002
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2003
	struct buffer_head *dibh;
2004
	struct gfs2_rgrpd *rgd;
2005 2006
	unsigned int ndata;
	u32 goal, blk; /* block, within the rgrp scope */
2007
	u64 block; /* block, within the file system scope */
2008
	int error;
B
Bob Peterson 已提交
2009
	struct gfs2_bitmap *bi;
D
David Teigland 已提交
2010

2011
	/* If we have a reservation, claim blocks from it. */
B
Bob Peterson 已提交
2012 2013 2014 2015
	if (gfs2_rs_active(ip->i_res)) {
		BUG_ON(!ip->i_res->rs_free);
		rgd = ip->i_res->rs_rgd;
		block = claim_reserved_blks(ip, dinode, nblocks);
2016 2017 2018
		if (*nblocks)
			goto found_blocks;
	}
2019

2020
	rgd = ip->i_rgd;
D
David Teigland 已提交
2021

2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034
	if (!dinode && rgrp_contains_block(rgd, ip->i_goal))
		goal = ip->i_goal - rgd->rd_data0;
	else
		goal = rgd->rd_last_alloc;

	blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, &bi);

	/* Since all blocks are reserved in advance, this shouldn't happen */
	if (blk == BFITNOENT) {
		printk(KERN_WARNING "BFITNOENT, nblocks=%u\n", *nblocks);
		printk(KERN_WARNING "FULL=%d\n",
		       test_bit(GBF_FULL, &rgd->rd_bits->bi_flags));
		goto rgrp_error;
B
Bob Peterson 已提交
2035
	}
2036 2037 2038

	block = gfs2_alloc_extent(rgd, bi, blk, dinode, nblocks);
found_blocks:
2039 2040 2041
	ndata = *nblocks;
	if (dinode)
		ndata--;
B
Bob Peterson 已提交
2042

2043
	if (!dinode) {
2044
		ip->i_goal = block + ndata - 1;
2045 2046 2047 2048 2049 2050 2051 2052 2053
		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);
		}
2054
	}
B
Bob Peterson 已提交
2055 2056
	if (rgd->rd_free < *nblocks) {
		printk(KERN_WARNING "nblocks=%u\n", *nblocks);
2057
		goto rgrp_error;
B
Bob Peterson 已提交
2058
	}
2059

2060
	rgd->rd_free -= *nblocks;
2061 2062 2063 2064 2065 2066
	if (dinode) {
		rgd->rd_dinodes++;
		*generation = rgd->rd_igeneration++;
		if (*generation == 0)
			*generation = rgd->rd_igeneration++;
	}
D
David Teigland 已提交
2067

2068
	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
2069
	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2070
	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
D
David Teigland 已提交
2071

2072
	gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
2073 2074
	if (dinode)
		gfs2_trans_add_unrevoke(sdp, block, 1);
2075 2076 2077 2078 2079 2080 2081

	/*
	 * 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,
2082
				  ip->i_inode.i_gid);
D
David Teigland 已提交
2083

2084
	rgd->rd_free_clone -= *nblocks;
2085
	trace_gfs2_block_alloc(ip, rgd, block, *nblocks,
2086
			       dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
2087 2088 2089 2090 2091 2092
	*bn = block;
	return 0;

rgrp_error:
	gfs2_rgrp_error(rgd);
	return -EIO;
D
David Teigland 已提交
2093 2094 2095
}

/**
2096
 * __gfs2_free_blocks - free a contiguous run of block(s)
D
David Teigland 已提交
2097 2098 2099
 * @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
2100
 * @meta: 1 if the blocks represent metadata
D
David Teigland 已提交
2101 2102 2103
 *
 */

2104
void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta)
D
David Teigland 已提交
2105
{
2106
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
2107 2108 2109 2110 2111
	struct gfs2_rgrpd *rgd;

	rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
	if (!rgd)
		return;
2112
	trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
2113
	rgd->rd_free += blen;
S
Steven Whitehouse 已提交
2114
	rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
2115
	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
2116
	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2117
	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
D
David Teigland 已提交
2118

2119
	/* Directories keep their data in the metadata address space */
2120
	if (meta || ip->i_depth)
2121
		gfs2_meta_wipe(ip, bstart, blen);
2122
}
D
David Teigland 已提交
2123

2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135
/**
 * 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);

2136
	__gfs2_free_blocks(ip, bstart, blen, 1);
D
David Teigland 已提交
2137
	gfs2_statfs_change(sdp, 0, +blen, 0);
2138
	gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
D
David Teigland 已提交
2139 2140
}

2141 2142 2143 2144 2145
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;
2146
	u64 blkno = ip->i_no_addr;
2147 2148 2149 2150

	rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);
	if (!rgd)
		return;
2151
	trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
2152
	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
2153
	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2154 2155
	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
	update_rgrp_lvb_unlinked(rgd, 1);
2156 2157
}

2158
static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
D
David Teigland 已提交
2159 2160 2161 2162 2163 2164 2165 2166 2167
{
	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);

2168
	if (!rgd->rd_dinodes)
D
David Teigland 已提交
2169
		gfs2_consist_rgrpd(rgd);
2170
	rgd->rd_dinodes--;
2171
	rgd->rd_free++;
D
David Teigland 已提交
2172

2173
	gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
2174
	gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2175 2176
	gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
	update_rgrp_lvb_unlinked(rgd, -1);
D
David Teigland 已提交
2177 2178 2179 2180 2181 2182 2183

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


void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
{
2184
	gfs2_free_uninit_di(rgd, ip->i_no_addr);
2185
	trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
2186
	gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
2187
	gfs2_meta_wipe(ip, ip->i_no_addr, 1);
D
David Teigland 已提交
2188 2189
}

2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203
/**
 * 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;
2204
	struct gfs2_holder rgd_gh;
2205
	int error = -EINVAL;
2206

S
Steven Whitehouse 已提交
2207
	rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
2208
	if (!rgd)
2209
		goto fail;
2210 2211 2212

	error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
	if (error)
2213
		goto fail;
2214 2215 2216 2217 2218 2219 2220 2221 2222

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

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

D
David Teigland 已提交
2223 2224
/**
 * gfs2_rlist_add - add a RG to a list of RGs
2225
 * @ip: the inode
D
David Teigland 已提交
2226 2227 2228 2229 2230 2231 2232 2233 2234
 * @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
 *
 */

2235
void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
2236
		    u64 block)
D
David Teigland 已提交
2237
{
2238
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
D
David Teigland 已提交
2239 2240 2241 2242 2243 2244 2245 2246
	struct gfs2_rgrpd *rgd;
	struct gfs2_rgrpd **tmp;
	unsigned int new_space;
	unsigned int x;

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

2247 2248 2249
	if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, block))
		rgd = ip->i_rgd;
	else
S
Steven Whitehouse 已提交
2250
		rgd = gfs2_blk2rgrpd(sdp, block, 1);
D
David Teigland 已提交
2251
	if (!rgd) {
2252
		fs_err(sdp, "rlist_add: no rgrp for block %llu\n", (unsigned long long)block);
D
David Teigland 已提交
2253 2254
		return;
	}
2255
	ip->i_rgd = rgd;
D
David Teigland 已提交
2256 2257 2258 2259 2260 2261 2262 2263 2264

	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 *),
2265
			      GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289

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

2290
void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state)
D
David Teigland 已提交
2291 2292 2293 2294
{
	unsigned int x;

	rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder),
2295
				GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
2296 2297
	for (x = 0; x < rlist->rl_rgrps; x++)
		gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
2298
				state, 0,
D
David Teigland 已提交
2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317
				&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 已提交
2318
		rlist->rl_ghs = NULL;
D
David Teigland 已提交
2319 2320 2321
	}
}