rgrp.c 65.7 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>
Steven Whitehouse's avatar
Steven Whitehouse committed
19
#include <linux/random.h>
David Teigland's avatar
David Teigland committed
20
21

#include "gfs2.h"
22
#include "incore.h"
David Teigland's avatar
David Teigland committed
23
24
25
26
27
28
29
30
#include "glock.h"
#include "glops.h"
#include "lops.h"
#include "meta_io.h"
#include "quota.h"
#include "rgrp.h"
#include "super.h"
#include "trans.h"
31
#include "util.h"
32
#include "log.h"
33
#include "inode.h"
Steven Whitehouse's avatar
Steven Whitehouse committed
34
#include "trace_gfs2.h"
David Teigland's avatar
David Teigland committed
35

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

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

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

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

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

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


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

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

Bob Peterson's avatar
Bob Peterson committed
94
95
	byte1 = bi->bi_bh->b_data + bi->bi_offset + (rbm->offset / GFS2_NBBY);
	end = bi->bi_bh->b_data + bi->bi_offset + buflen;
96

97
	BUG_ON(byte1 >= end);
98

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

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

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

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

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

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

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

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

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

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

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

195
196
197
/**
 * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
 *       a block in a given allocation state.
198
 * @buf: the buffer that holds the bitmaps
199
 * @len: the length (in bytes) of the buffer
200
 * @goal: start search at this block's bit-pair (within @buffer)
201
 * @state: GFS2_BLKST_XXX the state of the block we're looking for.
202
203
204
 *
 * Scope of @goal and returned block number is only within this bitmap buffer,
 * not entire rgrp or filesystem.  @buffer will be offset from the actual
205
206
207
208
209
 * beginning of a bitmap block buffer, skipping any header structures, but
 * headers are always a multiple of 64 bits long so that the buffer is
 * always aligned to a 64 bit boundary.
 *
 * The size of the buffer is in bytes, but is it assumed that it is
210
 * always ok to read a complete multiple of 64 bits at the end
211
 * of the block in case the end is no aligned to a natural boundary.
212
213
214
215
 *
 * Return: the block number (bitmap buffer scope) that was found
 */

216
217
static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
		       u32 goal, u8 state)
218
{
219
220
221
222
	u32 spoint = (goal << 1) & ((8*sizeof(u64)) - 1);
	const __le64 *ptr = ((__le64 *)buf) + (goal >> 5);
	const __le64 *end = (__le64 *)(buf + ALIGN(len, sizeof(u64)));
	u64 tmp;
223
	u64 mask = 0x5555555555555555ULL;
224
225
226
227
228
229
230
	u32 bit;

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

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

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

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

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

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

282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
/**
 * gfs2_rbm_incr - increment an rbm structure
 * @rbm: The rbm with rgd already set correctly
 *
 * This function takes an existing rbm structure and increments it to the next
 * viable block offset.
 *
 * Returns: If incrementing the offset would cause the rbm to go past the
 *          end of the rgrp, true is returned, otherwise false.
 *
 */

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

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

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

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

	for (n = 0; n < n_unaligned; n++) {
		res = gfs2_testbit(rbm);
		if (res != GFS2_BLKST_FREE)
			return true;
		(*len)--;
		if (*len == 0)
			return true;
329
		if (gfs2_rbm_incr(rbm))
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
			return true;
	}

	return false;
}

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

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

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

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

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

402
403
/**
 * gfs2_bitcount - count the number of bits in a certain state
404
 * @rgd: the resource group descriptor
405
406
407
408
409
410
411
 * @buffer: the buffer that holds the bitmaps
 * @buflen: the length (in bytes) of the buffer
 * @state: the state of the block we're looking for
 *
 * Returns: The number of bits
 */

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

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

	return count;
}

David Teigland's avatar
David Teigland committed
436
437
438
439
440
441
442
443
444
445
/**
 * gfs2_rgrp_verify - Verify that a resource group is consistent
 * @rgd: the rgrp
 *
 */

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

450
	memset(count, 0, 4 * sizeof(u32));
David Teigland's avatar
David Teigland committed
451
452
453
454
455
456
457
458
459
460
461

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

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

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

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

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

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

Steven Whitehouse's avatar
Steven Whitehouse committed
501
struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
David Teigland's avatar
David Teigland committed
502
{
Steven Whitehouse's avatar
Steven Whitehouse committed
503
	struct rb_node *n, *next;
504
	struct gfs2_rgrpd *cur;
David Teigland's avatar
David Teigland committed
505
506

	spin_lock(&sdp->sd_rindex_spin);
Steven Whitehouse's avatar
Steven Whitehouse committed
507
508
509
510
	n = sdp->sd_rindex_tree.rb_node;
	while (n) {
		cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
		next = NULL;
511
		if (blk < cur->rd_addr)
Steven Whitehouse's avatar
Steven Whitehouse committed
512
			next = n->rb_left;
513
		else if (blk >= cur->rd_data0 + cur->rd_data)
Steven Whitehouse's avatar
Steven Whitehouse committed
514
515
			next = n->rb_right;
		if (next == NULL) {
David Teigland's avatar
David Teigland committed
516
			spin_unlock(&sdp->sd_rindex_spin);
Steven Whitehouse's avatar
Steven Whitehouse committed
517
518
519
520
521
522
			if (exact) {
				if (blk < cur->rd_addr)
					return NULL;
				if (blk >= cur->rd_data0 + cur->rd_data)
					return NULL;
			}
523
			return cur;
David Teigland's avatar
David Teigland committed
524
		}
Steven Whitehouse's avatar
Steven Whitehouse committed
525
		n = next;
David Teigland's avatar
David Teigland committed
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
	}
	spin_unlock(&sdp->sd_rindex_spin);

	return NULL;
}

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

struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp)
{
541
542
543
	const struct rb_node *n;
	struct gfs2_rgrpd *rgd;

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

	return rgd;
David Teigland's avatar
David Teigland committed
550
551
552
553
}

/**
 * gfs2_rgrpd_get_next - get the next RG
554
 * @rgd: the resource group descriptor
David Teigland's avatar
David Teigland committed
555
556
557
558
559
560
 *
 * Returns: The next rgrp
 */

struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
{
561
562
563
564
565
566
567
568
569
570
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	const struct rb_node *n;

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

	if (unlikely(&rgd->rd_node == n)) {
		spin_unlock(&sdp->sd_rindex_spin);
David Teigland's avatar
David Teigland committed
571
		return NULL;
572
573
574
575
	}
	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
	spin_unlock(&sdp->sd_rindex_spin);
	return rgd;
David Teigland's avatar
David Teigland committed
576
577
}

578
579
580
581
582
583
584
585
586
587
588
void gfs2_free_clones(struct gfs2_rgrpd *rgd)
{
	int x;

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

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

Abhijith Das's avatar
Abhijith Das committed
597
	down_write(&ip->i_rw_mutex);
Bob Peterson's avatar
Bob Peterson committed
598
	if (ip->i_res)
Abhijith Das's avatar
Abhijith Das committed
599
		goto out;
600

Abhijith Das's avatar
Abhijith Das committed
601
602
603
604
605
	ip->i_res = kmem_cache_zalloc(gfs2_rsrv_cachep, GFP_NOFS);
	if (!ip->i_res) {
		error = -ENOMEM;
		goto out;
	}
606

Abhijith Das's avatar
Abhijith Das committed
607
608
	RB_CLEAR_NODE(&ip->i_res->rs_node);
out:
609
	up_write(&ip->i_rw_mutex);
610
	return error;
611
612
}

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

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

	if (!gfs2_rs_active(rs))
		return;

633
	rgd = rs->rs_rbm.rgd;
634
	trace_gfs2_rs(rs, TRACE_RS_TREEDEL);
635
	rb_erase(&rs->rs_node, &rgd->rd_rstree);
636
	RB_CLEAR_NODE(&rs->rs_node);
Bob Peterson's avatar
Bob Peterson committed
637
638

	if (rs->rs_free) {
Bob Peterson's avatar
Bob Peterson committed
639
640
		struct gfs2_bitmap *bi = rbm_bi(&rs->rs_rbm);

641
		/* return reserved blocks to the rgrp */
642
643
		BUG_ON(rs->rs_rbm.rgd->rd_reserved < rs->rs_free);
		rs->rs_rbm.rgd->rd_reserved -= rs->rs_free;
644
645
646
647
648
		/* The rgrp extent failure point is likely not to increase;
		   it will only do so if the freed blocks are somehow
		   contiguous with a span of free blocks that follows. Still,
		   it will force the number to be recalculated later. */
		rgd->rd_extfail_pt += rs->rs_free;
Bob Peterson's avatar
Bob Peterson committed
649
		rs->rs_free = 0;
Bob Peterson's avatar
Bob Peterson committed
650
		clear_bit(GBF_FULL, &bi->bi_flags);
Bob Peterson's avatar
Bob Peterson committed
651
652
653
654
655
656
657
658
	}
}

/**
 * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
 * @rs: The reservation to remove
 *
 */
659
void gfs2_rs_deltree(struct gfs2_blkreserv *rs)
Bob Peterson's avatar
Bob Peterson committed
660
661
662
{
	struct gfs2_rgrpd *rgd;

663
664
665
	rgd = rs->rs_rbm.rgd;
	if (rgd) {
		spin_lock(&rgd->rd_rsspin);
666
		__rs_deltree(rs);
667
668
		spin_unlock(&rgd->rd_rsspin);
	}
Bob Peterson's avatar
Bob Peterson committed
669
670
671
672
}

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

Bob Peterson's avatar
Bob Peterson committed
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
/**
 * 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);
705
		__rs_deltree(rs);
Bob Peterson's avatar
Bob Peterson committed
706
707
708
709
	}
	spin_unlock(&rgd->rd_rsspin);
}

710
void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
David Teigland's avatar
David Teigland committed
711
{
712
	struct rb_node *n;
David Teigland's avatar
David Teigland committed
713
714
715
	struct gfs2_rgrpd *rgd;
	struct gfs2_glock *gl;

716
717
	while ((n = rb_first(&sdp->sd_rindex_tree))) {
		rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
David Teigland's avatar
David Teigland committed
718
719
		gl = rgd->rd_gl;

720
		rb_erase(n, &sdp->sd_rindex_tree);
David Teigland's avatar
David Teigland committed
721
722

		if (gl) {
723
			spin_lock(&gl->gl_spin);
724
			gl->gl_object = NULL;
725
			spin_unlock(&gl->gl_spin);
726
			gfs2_glock_add_to_lru(gl);
David Teigland's avatar
David Teigland committed
727
728
729
			gfs2_glock_put(gl);
		}

730
		gfs2_free_clones(rgd);
David Teigland's avatar
David Teigland committed
731
		kfree(rgd->rd_bits);
Bob Peterson's avatar
Bob Peterson committed
732
		return_all_reservations(rgd);
733
		kmem_cache_free(gfs2_rgrpd_cachep, rgd);
David Teigland's avatar
David Teigland committed
734
735
736
	}
}

737
738
739
740
741
742
743
744
745
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
746
747
748
749
750
751
752
753
754
755
756
757
758
/**
 * 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;
759
	u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
760
	u32 bytes_left, bytes;
David Teigland's avatar
David Teigland committed
761
762
	int x;

763
764
765
	if (!length)
		return -EINVAL;

766
	rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
David Teigland's avatar
David Teigland committed
767
768
769
	if (!rgd->rd_bits)
		return -ENOMEM;

770
	bytes_left = rgd->rd_bitbytes;
David Teigland's avatar
David Teigland committed
771
772
773
774

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

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

		bytes_left -= bytes;
	}

	if (bytes_left) {
		gfs2_consist_rgrpd(rgd);
		return -EIO;
	}
	bi = rgd->rd_bits + (length - 1);
815
	if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
David Teigland's avatar
David Teigland committed
816
		if (gfs2_consist_rgrpd(rgd)) {
817
			gfs2_rindex_print(rgd);
David Teigland's avatar
David Teigland committed
818
819
820
821
822
823
824
825
826
			fs_err(sdp, "start=%u len=%u offset=%u\n",
			       bi->bi_start, bi->bi_len, bi->bi_offset);
		}
		return -EIO;
	}

	return 0;
}

827
828
/**
 * gfs2_ri_total - Total up the file system space, according to the rindex.
829
 * @sdp: the filesystem
830
831
832
833
834
835
836
837
838
839
840
841
842
 *
 */
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);

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

Bob Peterson's avatar
Bob Peterson committed
854
static int rgd_insert(struct gfs2_rgrpd *rgd)
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
{
	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
870
			return -EEXIST;
871
872
873
874
	}

	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
875
876
	sdp->sd_rgrps++;
	return 0;
877
878
}

David Teigland's avatar
David Teigland committed
879
/**
880
 * read_rindex_entry - Pull in a new resource index entry from the disk
881
 * @ip: Pointer to the rindex inode
David Teigland's avatar
David Teigland committed
882
 *
883
 * Returns: 0 on success, > 0 on EOF, error code otherwise
884
885
 */

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

894
895
896
	if (pos >= i_size_read(&ip->i_inode))
		return 1;

897
	error = gfs2_internal_read(ip, (char *)&buf, &pos,
898
				   sizeof(struct gfs2_rindex));
899
900
901

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

903
	rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
904
905
906
907
908
	error = -ENOMEM;
	if (!rgd)
		return error;

	rgd->rd_sbd = sdp;
909
910
911
912
913
	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);
Bob Peterson's avatar
Bob Peterson committed
914
	spin_lock_init(&rgd->rd_rsspin);
915

916
917
	error = compute_bitstructs(rgd);
	if (error)
918
		goto fail;
919

920
	error = gfs2_glock_get(sdp, rgd->rd_addr,
921
922
			       &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
	if (error)
923
		goto fail;
924
925

	rgd->rd_gl->gl_object = rgd;
926
	rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lksb.sb_lvbptr;
927
	rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
928
929
	if (rgd->rd_data > sdp->sd_max_rg_data)
		sdp->sd_max_rg_data = rgd->rd_data;
930
	spin_lock(&sdp->sd_rindex_spin);
Bob Peterson's avatar
Bob Peterson committed
931
	error = rgd_insert(rgd);
932
	spin_unlock(&sdp->sd_rindex_spin);
Bob Peterson's avatar
Bob Peterson committed
933
934
935
936
	if (!error)
		return 0;

	error = 0; /* someone else read in the rgrp; free it and ignore it */
937
	gfs2_glock_put(rgd->rd_gl);
938
939
940
941

fail:
	kfree(rgd->rd_bits);
	kmem_cache_free(gfs2_rgrpd_cachep, rgd);
942
943
944
945
946
947
948
	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
949
950
951
 * Returns: 0 on successful update, error code otherwise
 */

952
static int gfs2_ri_update(struct gfs2_inode *ip)
David Teigland's avatar
David Teigland committed
953
{
954
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teigland's avatar
David Teigland committed
955
956
	int error;

957
	do {
958
		error = read_rindex_entry(ip);
959
960
961
962
	} while (error == 0);

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

964
	sdp->sd_rindex_uptodate = 1;
965
966
	return 0;
}
David Teigland's avatar
David Teigland committed
967
968

/**
969
 * gfs2_rindex_update - Update the rindex if required
David Teigland's avatar
David Teigland committed
970
971
972
973
974
975
976
977
978
979
980
981
 * @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.
 *
982
 * Returns: 0 on succeess, error code otherwise
David Teigland's avatar
David Teigland committed
983
984
 */

985
int gfs2_rindex_update(struct gfs2_sbd *sdp)
David Teigland's avatar
David Teigland committed
986
{
987
	struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
David Teigland's avatar
David Teigland committed
988
	struct gfs2_glock *gl = ip->i_gl;
989
990
	struct gfs2_holder ri_gh;
	int error = 0;
991
	int unlock_required = 0;
David Teigland's avatar
David Teigland committed
992
993

	/* Read new copy from disk if we don't have the latest */
994
	if (!sdp->sd_rindex_uptodate) {
995
996
997
		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
998
				return error;
999
1000
			unlock_required = 1;
		}
1001
		if (!sdp->sd_rindex_uptodate)
David Teigland's avatar
David Teigland committed
1002
			error = gfs2_ri_update(ip);
1003
1004
		if (unlock_required)
			gfs2_glock_dq_uninit(&ri_gh);
David Teigland's avatar
David Teigland committed
1005
1006
1007
1008
1009
	}

	return error;
}

1010
static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
1011
1012
{
	const struct gfs2_rgrp *str = buf;
1013
	u32 rg_flags;
1014

1015
	rg_flags = be32_to_cpu(str->rg_flags);
1016
	rg_flags &= ~GFS2_RDF_MASK;
1017
1018
	rgd->rd_flags &= GFS2_RDF_MASK;
	rgd->rd_flags |= rg_flags;
1019
	rgd->rd_free = be32_to_cpu(str->rg_free);
1020
	rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
1021
	rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
1022
1023
}

1024
static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
1025
1026
1027
{
	struct gfs2_rgrp *str = buf;

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

1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
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
1092
/**
1093
1094
 * 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
1095
1096
1097
1098
1099
1100
1101
 *
 * 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
 */

1102
int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
David Teigland's avatar
David Teigland committed
1103
1104
1105
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct gfs2_glock *gl = rgd->rd_gl;
1106
	unsigned int length = rgd->rd_length;
David Teigland's avatar
David Teigland committed
1107
1108
1109
1110
	struct gfs2_bitmap *bi;
	unsigned int x, y;
	int error;

1111
1112
1113
	if (rgd->rd_bits[0].bi_bh != NULL)
		return 0;

David Teigland's avatar
David Teigland committed
1114
1115
	for (x = 0; x < length; x++) {
		bi = rgd->rd_bits + x;
1116
		error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
David Teigland's avatar
David Teigland committed
1117
1118
1119
1120
1121
1122
		if (error)
			goto fail;
	}

	for (y = length; y--;) {
		bi = rgd->rd_bits + y;
1123
		error = gfs2_meta_wait(sdp, bi->bi_bh);
David Teigland's avatar
David Teigland committed
1124
1125
		if (error)
			goto fail;
1126
		if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
David Teigland's avatar
David Teigland committed
1127
1128
1129
1130
1131
1132
					      GFS2_METATYPE_RG)) {
			error = -EIO;
			goto fail;
		}
	}

1133
	if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
1134
1135
		for (x = 0; x < length; x++)
			clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
1136
		gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
1137
		rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
1138
		rgd->rd_free_clone = rgd->rd_free;
1139
1140
		/* max out the rgrp allocation failure point */
		rgd->rd_extfail_pt = rgd->rd_free;
David Teigland's avatar
David Teigland committed
1141
	}
Al Viro's avatar
Al Viro committed
1142
	if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
		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
1156
1157
	return 0;

1158
fail:
David Teigland's avatar
David Teigland committed
1159
1160
1161
116