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

#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>
David Teigland's avatar
David Teigland committed
19 20

#include "gfs2.h"
21
#include "incore.h"
David Teigland's avatar
David Teigland committed
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"
Steven Whitehouse's avatar
Steven Whitehouse committed
33
#include "trace_gfs2.h"
David Teigland's avatar
David Teigland committed
34

Steven Whitehouse's avatar
Steven Whitehouse committed
35
#define BFITNOENT ((u32)~0)
36
#define NO_BLOCK ((u64)~0)
37

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

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

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

67
static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
68
			unsigned char old_state,
69
			struct gfs2_bitmap **rbi);
70

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

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

89 90
	byte1 = bi->bi_bh->b_data + bi->bi_offset + (block / GFS2_NBBY);
	end = bi->bi_bh->b_data + bi->bi_offset + buflen;
91

92
	BUG_ON(byte1 >= end);
93

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

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

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

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

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

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

180 181 182
/**
 * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
 *       a block in a given allocation state.
183
 * @buf: the buffer that holds the bitmaps
184
 * @len: the length (in bytes) of the buffer
185
 * @goal: start search at this block's bit-pair (within @buffer)
186
 * @state: GFS2_BLKST_XXX the state of the block we're looking for.
187 188 189
 *
 * 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
190 191 192 193 194
 * 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
195
 * always ok to read a complete multiple of 64 bits at the end
196
 * of the block in case the end is no aligned to a natural boundary.
197 198 199 200
 *
 * Return: the block number (bitmap buffer scope) that was found
 */

201 202
static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
		       u32 goal, u8 state)
203
{
204 205 206 207
	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;
208
	u64 mask = 0x5555555555555555ULL;
209 210 211 212 213 214 215 216 217
	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) {
218
		tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
219
		ptr++;
220
	}
221 222 223 224 225 226 227
	/* 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--;
228
	bit = __ffs64(tmp);
229 230
	bit /= 2;	/* two bits per entry in the bitmap */
	return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
231 232 233 234
}

/**
 * gfs2_bitcount - count the number of bits in a certain state
235
 * @rgd: the resource group descriptor
236 237 238 239 240 241 242
 * @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
 */

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

	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;
}

David Teigland's avatar
David Teigland committed
267 268 269 270 271 272 273 274 275 276
/**
 * 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;
277
	u32 length = rgd->rd_length;
278
	u32 count[4], tmp;
David Teigland's avatar
David Teigland committed
279 280
	int buf, x;

281
	memset(count, 0, 4 * sizeof(u32));
David Teigland's avatar
David Teigland committed
282 283 284 285 286 287 288 289 290 291 292

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

293
	if (count[0] != rgd->rd_free) {
David Teigland's avatar
David Teigland committed
294 295
		if (gfs2_consist_rgrpd(rgd))
			fs_err(sdp, "free data mismatch:  %u != %u\n",
296
			       count[0], rgd->rd_free);
David Teigland's avatar
David Teigland committed
297 298 299
		return;
	}

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

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

316
static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block)
David Teigland's avatar
David Teigland committed
317
{
318 319
	u64 first = rgd->rd_data0;
	u64 last = first + rgd->rd_data;
320
	return first <= block && block < last;
David Teigland's avatar
David Teigland committed
321 322 323 324 325
}

/**
 * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
 * @sdp: The GFS2 superblock
326 327
 * @blk: The data block number
 * @exact: True if this needs to be an exact match
David Teigland's avatar
David Teigland committed
328 329 330 331
 *
 * Returns: The resource group, or NULL if not found
 */

Steven Whitehouse's avatar
Steven Whitehouse committed
332
struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
David Teigland's avatar
David Teigland committed
333
{
Steven Whitehouse's avatar
Steven Whitehouse committed
334
	struct rb_node *n, *next;
335
	struct gfs2_rgrpd *cur;
David Teigland's avatar
David Teigland committed
336 337

	spin_lock(&sdp->sd_rindex_spin);
Steven Whitehouse's avatar
Steven Whitehouse committed
338 339 340 341
	n = sdp->sd_rindex_tree.rb_node;
	while (n) {
		cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
		next = NULL;
342
		if (blk < cur->rd_addr)
Steven Whitehouse's avatar
Steven Whitehouse committed
343
			next = n->rb_left;
344
		else if (blk >= cur->rd_data0 + cur->rd_data)
Steven Whitehouse's avatar
Steven Whitehouse committed
345 346
			next = n->rb_right;
		if (next == NULL) {
David Teigland's avatar
David Teigland committed
347
			spin_unlock(&sdp->sd_rindex_spin);
Steven Whitehouse's avatar
Steven Whitehouse committed
348 349 350 351 352 353
			if (exact) {
				if (blk < cur->rd_addr)
					return NULL;
				if (blk >= cur->rd_data0 + cur->rd_data)
					return NULL;
			}
354
			return cur;
David Teigland's avatar
David Teigland committed
355
		}
Steven Whitehouse's avatar
Steven Whitehouse committed
356
		n = next;
David Teigland's avatar
David Teigland committed
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
	}
	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)
{
372 373 374
	const struct rb_node *n;
	struct gfs2_rgrpd *rgd;

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

	return rgd;
David Teigland's avatar
David Teigland committed
381 382 383 384
}

/**
 * gfs2_rgrpd_get_next - get the next RG
385
 * @rgd: the resource group descriptor
David Teigland's avatar
David Teigland committed
386 387 388 389 390 391
 *
 * Returns: The next rgrp
 */

struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
{
392 393 394 395 396 397 398 399 400 401
	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);
David Teigland's avatar
David Teigland committed
402
		return NULL;
403 404 405 406
	}
	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
	spin_unlock(&sdp->sd_rindex_spin);
	return rgd;
David Teigland's avatar
David Teigland committed
407 408
}

409 410 411 412 413 414 415 416 417 418 419
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;
	}
}

420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
/**
 * 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;

	down_write(&ip->i_rw_mutex);
	if (!ip->i_res) {
		ip->i_res = kmem_cache_zalloc(gfs2_rsrv_cachep, GFP_NOFS);
		if (!ip->i_res)
			error = -ENOMEM;
	}
	up_write(&ip->i_rw_mutex);
	return error;
}

/**
 * gfs2_rs_delete - delete a reservation
 * @ip: The inode for this reservation
 *
 */
void gfs2_rs_delete(struct gfs2_inode *ip)
{
	down_write(&ip->i_rw_mutex);
	if (ip->i_res) {
		kmem_cache_free(gfs2_rsrv_cachep, ip->i_res);
		ip->i_res = NULL;
	}
	up_write(&ip->i_rw_mutex);
}

453
void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
David Teigland's avatar
David Teigland committed
454
{
455
	struct rb_node *n;
David Teigland's avatar
David Teigland committed
456 457 458
	struct gfs2_rgrpd *rgd;
	struct gfs2_glock *gl;

459 460
	while ((n = rb_first(&sdp->sd_rindex_tree))) {
		rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
David Teigland's avatar
David Teigland committed
461 462
		gl = rgd->rd_gl;

463
		rb_erase(n, &sdp->sd_rindex_tree);
David Teigland's avatar
David Teigland committed
464 465

		if (gl) {
466
			spin_lock(&gl->gl_spin);
467
			gl->gl_object = NULL;
468
			spin_unlock(&gl->gl_spin);
469
			gfs2_glock_add_to_lru(gl);
David Teigland's avatar
David Teigland committed
470 471 472
			gfs2_glock_put(gl);
		}

473
		gfs2_free_clones(rgd);
David Teigland's avatar
David Teigland committed
474
		kfree(rgd->rd_bits);
475
		kmem_cache_free(gfs2_rgrpd_cachep, rgd);
David Teigland's avatar
David Teigland committed
476 477 478
	}
}

479 480 481 482 483 484 485 486 487
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);
}

David Teigland's avatar
David Teigland committed
488 489 490 491 492 493 494 495 496 497 498 499 500
/**
 * 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;
501
	u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
502
	u32 bytes_left, bytes;
David Teigland's avatar
David Teigland committed
503 504
	int x;

505 506 507
	if (!length)
		return -EINVAL;

508
	rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
David Teigland's avatar
David Teigland committed
509 510 511
	if (!rgd->rd_bits)
		return -ENOMEM;

512
	bytes_left = rgd->rd_bitbytes;
David Teigland's avatar
David Teigland committed
513 514 515 516

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

517
		bi->bi_flags = 0;
David Teigland's avatar
David Teigland committed
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
		/* 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);
534
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teigland's avatar
David Teigland committed
535 536 537
			bi->bi_len = bytes;
		/* other blocks */
		} else {
538 539
			bytes = sdp->sd_sb.sb_bsize -
				sizeof(struct gfs2_meta_header);
David Teigland's avatar
David Teigland committed
540
			bi->bi_offset = sizeof(struct gfs2_meta_header);
541
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teigland's avatar
David Teigland committed
542 543 544 545 546 547 548 549 550 551 552
			bi->bi_len = bytes;
		}

		bytes_left -= bytes;
	}

	if (bytes_left) {
		gfs2_consist_rgrpd(rgd);
		return -EIO;
	}
	bi = rgd->rd_bits + (length - 1);
553
	if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
David Teigland's avatar
David Teigland committed
554
		if (gfs2_consist_rgrpd(rgd)) {
555
			gfs2_rindex_print(rgd);
David Teigland's avatar
David Teigland committed
556 557 558 559 560 561 562 563 564
			fs_err(sdp, "start=%u len=%u offset=%u\n",
			       bi->bi_start, bi->bi_len, bi->bi_offset);
		}
		return -EIO;
	}

	return 0;
}

565 566
/**
 * gfs2_ri_total - Total up the file system space, according to the rindex.
567
 * @sdp: the filesystem
568 569 570 571 572 573 574 575 576 577 578 579 580
 *
 */
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);

581
		if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
582
			break;
583
		error = gfs2_internal_read(ip, buf, &pos,
584 585 586
					   sizeof(struct gfs2_rindex));
		if (error != sizeof(struct gfs2_rindex))
			break;
587
		total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
588 589 590 591
	}
	return total_data;
}

Bob Peterson's avatar
Bob Peterson committed
592
static int rgd_insert(struct gfs2_rgrpd *rgd)
593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
{
	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
Bob Peterson's avatar
Bob Peterson committed
608
			return -EEXIST;
609 610 611 612
	}

	rb_link_node(&rgd->rd_node, parent, newn);
	rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
Bob Peterson's avatar
Bob Peterson committed
613 614
	sdp->sd_rgrps++;
	return 0;
615 616
}

David Teigland's avatar
David Teigland committed
617
/**
618
 * read_rindex_entry - Pull in a new resource index entry from the disk
619
 * @ip: Pointer to the rindex inode
David Teigland's avatar
David Teigland committed
620
 *
621
 * Returns: 0 on success, > 0 on EOF, error code otherwise
622 623
 */

624
static int read_rindex_entry(struct gfs2_inode *ip)
625 626 627
{
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
628
	struct gfs2_rindex buf;
629 630 631
	int error;
	struct gfs2_rgrpd *rgd;

632 633 634
	if (pos >= i_size_read(&ip->i_inode))
		return 1;

635
	error = gfs2_internal_read(ip, (char *)&buf, &pos,
636
				   sizeof(struct gfs2_rindex));
637 638 639

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

641
	rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
642 643 644 645 646
	error = -ENOMEM;
	if (!rgd)
		return error;

	rgd->rd_sbd = sdp;
647 648 649 650 651
	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);
652

653 654
	error = compute_bitstructs(rgd);
	if (error)
655
		goto fail;
656

657
	error = gfs2_glock_get(sdp, rgd->rd_addr,
658 659
			       &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
	if (error)
660
		goto fail;
661 662

	rgd->rd_gl->gl_object = rgd;
663
	rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lvb;
664
	rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
665 666
	if (rgd->rd_data > sdp->sd_max_rg_data)
		sdp->sd_max_rg_data = rgd->rd_data;
667
	spin_lock(&sdp->sd_rindex_spin);
Bob Peterson's avatar
Bob Peterson committed
668
	error = rgd_insert(rgd);
669
	spin_unlock(&sdp->sd_rindex_spin);
Bob Peterson's avatar
Bob Peterson committed
670 671 672 673
	if (!error)
		return 0;

	error = 0; /* someone else read in the rgrp; free it and ignore it */
674
	gfs2_glock_put(rgd->rd_gl);
675 676 677 678

fail:
	kfree(rgd->rd_bits);
	kmem_cache_free(gfs2_rgrpd_cachep, rgd);
679 680 681 682 683 684 685
	return error;
}

/**
 * gfs2_ri_update - Pull in a new resource index from the disk
 * @ip: pointer to the rindex inode
 *
David Teigland's avatar
David Teigland committed
686 687 688
 * Returns: 0 on successful update, error code otherwise
 */

689
static int gfs2_ri_update(struct gfs2_inode *ip)
David Teigland's avatar
David Teigland committed
690
{
691
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teigland's avatar
David Teigland committed
692 693
	int error;

694
	do {
695
		error = read_rindex_entry(ip);
696 697 698 699
	} while (error == 0);

	if (error < 0)
		return error;
David Teigland's avatar
David Teigland committed
700

701
	sdp->sd_rindex_uptodate = 1;
702 703
	return 0;
}
David Teigland's avatar
David Teigland committed
704 705

/**
706
 * gfs2_rindex_update - Update the rindex if required
David Teigland's avatar
David Teigland committed
707 708 709 710 711 712 713 714 715 716 717 718
 * @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.
 *
719
 * Returns: 0 on succeess, error code otherwise
David Teigland's avatar
David Teigland committed
720 721
 */

722
int gfs2_rindex_update(struct gfs2_sbd *sdp)
David Teigland's avatar
David Teigland committed
723
{
724
	struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
David Teigland's avatar
David Teigland committed
725
	struct gfs2_glock *gl = ip->i_gl;
726 727
	struct gfs2_holder ri_gh;
	int error = 0;
728
	int unlock_required = 0;
David Teigland's avatar
David Teigland committed
729 730

	/* Read new copy from disk if we don't have the latest */
731
	if (!sdp->sd_rindex_uptodate) {
732 733 734
		if (!gfs2_glock_is_locked_by_me(gl)) {
			error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, &ri_gh);
			if (error)
Bob Peterson's avatar
Bob Peterson committed
735
				return error;
736 737
			unlock_required = 1;
		}
738
		if (!sdp->sd_rindex_uptodate)
David Teigland's avatar
David Teigland committed
739
			error = gfs2_ri_update(ip);
740 741
		if (unlock_required)
			gfs2_glock_dq_uninit(&ri_gh);
David Teigland's avatar
David Teigland committed
742 743 744 745 746
	}

	return error;
}

747
static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
748 749
{
	const struct gfs2_rgrp *str = buf;
750
	u32 rg_flags;
751

752
	rg_flags = be32_to_cpu(str->rg_flags);
753
	rg_flags &= ~GFS2_RDF_MASK;
754 755
	rgd->rd_flags &= GFS2_RDF_MASK;
	rgd->rd_flags |= rg_flags;
756
	rgd->rd_free = be32_to_cpu(str->rg_free);
757
	rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
758
	rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
759 760
}

761
static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
762 763 764
{
	struct gfs2_rgrp *str = buf;

765
	str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
766
	str->rg_free = cpu_to_be32(rgd->rd_free);
767
	str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
768
	str->__pad = cpu_to_be32(0);
769
	str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
770 771 772
	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
}

773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
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;
}


David Teigland's avatar
David Teigland committed
829
/**
830 831
 * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
 * @rgd: the struct gfs2_rgrpd describing the RG to read in
David Teigland's avatar
David Teigland committed
832 833 834 835 836 837 838
 *
 * 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
 */

839
int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
David Teigland's avatar
David Teigland committed
840 841 842
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct gfs2_glock *gl = rgd->rd_gl;
843
	unsigned int length = rgd->rd_length;
David Teigland's avatar
David Teigland committed
844 845 846 847
	struct gfs2_bitmap *bi;
	unsigned int x, y;
	int error;

848 849 850
	if (rgd->rd_bits[0].bi_bh != NULL)
		return 0;

David Teigland's avatar
David Teigland committed
851 852
	for (x = 0; x < length; x++) {
		bi = rgd->rd_bits + x;
853
		error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
David Teigland's avatar
David Teigland committed
854 855 856 857 858 859
		if (error)
			goto fail;
	}

	for (y = length; y--;) {
		bi = rgd->rd_bits + y;
860
		error = gfs2_meta_wait(sdp, bi->bi_bh);
David Teigland's avatar
David Teigland committed
861 862
		if (error)
			goto fail;
863
		if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
David Teigland's avatar
David Teigland committed
864 865 866 867 868 869
					      GFS2_METATYPE_RG)) {
			error = -EIO;
			goto fail;
		}
	}

870
	if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
871 872
		for (x = 0; x < length; x++)
			clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
873
		gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
874
		rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
875
		rgd->rd_free_clone = rgd->rd_free;
David Teigland's avatar
David Teigland committed
876
	}
877 878 879 880 881 882 883 884 885 886 887 888 889 890
	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;
	}
David Teigland's avatar
David Teigland committed
891 892
	return 0;

893
fail:
David Teigland's avatar
David Teigland committed
894 895 896 897 898 899 900 901 902 903
	while (x--) {
		bi = rgd->rd_bits + x;
		brelse(bi->bi_bh);
		bi->bi_bh = NULL;
		gfs2_assert_warn(sdp, !bi->bi_clone);
	}

	return error;
}

904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936
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);
}

David Teigland's avatar
David Teigland committed
937
/**
938
 * gfs2_rgrp_go_unlock - Release RG bitmaps read in with gfs2_rgrp_bh_get()
939
 * @gh: The glock holder for the resource group
David Teigland's avatar
David Teigland committed
940 941 942
 *
 */

943
void gfs2_rgrp_go_unlock(struct gfs2_holder *gh)
David Teigland's avatar
David Teigland committed
944
{
945
	struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
946
	int x, length = rgd->rd_length;
David Teigland's avatar
David Teigland committed
947 948 949

	for (x = 0; x < length; x++) {
		struct gfs2_bitmap *bi = rgd->rd_bits + x;
950 951 952 953
		if (bi->bi_bh) {
			brelse(bi->bi_bh);
			bi->bi_bh = NULL;
		}
David Teigland's avatar
David Teigland committed
954 955 956 957
	}

}

Steven Whitehouse's avatar
Steven Whitehouse committed
958
int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
959
			     struct buffer_head *bh,
Steven Whitehouse's avatar
Steven Whitehouse committed
960
			     const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
961 962 963 964
{
	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 /
965
					   bdev_logical_block_size(sb->s_bdev);
966
	u64 blk;
967
	sector_t start = 0;
968 969 970
	sector_t nr_sects = 0;
	int rv;
	unsigned int x;
Steven Whitehouse's avatar
Steven Whitehouse committed
971 972
	u32 trimmed = 0;
	u8 diff;
973 974

	for (x = 0; x < bi->bi_len; x++) {
Steven Whitehouse's avatar
Steven Whitehouse committed
975 976 977 978 979 980 981 982 983
		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));
		}