rgrp.c 64.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>
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;
Bob Peterson's avatar
Bob Peterson committed
644
		rs->rs_free = 0;
Bob Peterson's avatar
Bob Peterson committed
645
		clear_bit(GBF_FULL, &bi->bi_flags);
Bob Peterson's avatar
Bob Peterson committed
646
647
648
649
650
651
652
653
654
		smp_mb__after_clear_bit();
	}
}

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

659
660
661
	rgd = rs->rs_rbm.rgd;
	if (rgd) {
		spin_lock(&rgd->rd_rsspin);
662
		__rs_deltree(rs);
663
664
		spin_unlock(&rgd->rd_rsspin);
	}
Bob Peterson's avatar
Bob Peterson committed
665
666
667
668
}

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

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

	spin_lock(&rgd->rd_rsspin);
	while ((n = rb_first(&rgd->rd_rstree))) {
		rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
701
		__rs_deltree(rs);
Bob Peterson's avatar
Bob Peterson committed
702
703
704
705
	}
	spin_unlock(&rgd->rd_rsspin);
}

706
void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
David Teigland's avatar
David Teigland committed
707
{
708
	struct rb_node *n;
David Teigland's avatar
David Teigland committed
709
710
711
	struct gfs2_rgrpd *rgd;
	struct gfs2_glock *gl;

712
713
	while ((n = rb_first(&sdp->sd_rindex_tree))) {
		rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
David Teigland's avatar
David Teigland committed
714
715
		gl = rgd->rd_gl;

716
		rb_erase(n, &sdp->sd_rindex_tree);
David Teigland's avatar
David Teigland committed
717
718

		if (gl) {
719
			spin_lock(&gl->gl_spin);
720
			gl->gl_object = NULL;
721
			spin_unlock(&gl->gl_spin);
722
			gfs2_glock_add_to_lru(gl);
David Teigland's avatar
David Teigland committed
723
724
725
			gfs2_glock_put(gl);
		}

726
		gfs2_free_clones(rgd);
David Teigland's avatar
David Teigland committed
727
		kfree(rgd->rd_bits);
Bob Peterson's avatar
Bob Peterson committed
728
		return_all_reservations(rgd);
729
		kmem_cache_free(gfs2_rgrpd_cachep, rgd);
David Teigland's avatar
David Teigland committed
730
731
732
	}
}

733
734
735
736
737
738
739
740
741
static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd)
{
	printk(KERN_INFO "  ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
	printk(KERN_INFO "  ri_length = %u\n", rgd->rd_length);
	printk(KERN_INFO "  ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
	printk(KERN_INFO "  ri_data = %u\n", rgd->rd_data);
	printk(KERN_INFO "  ri_bitbytes = %u\n", rgd->rd_bitbytes);
}

David Teigland's avatar
David Teigland committed
742
743
744
745
746
747
748
749
750
751
752
753
754
/**
 * gfs2_compute_bitstructs - Compute the bitmap sizes
 * @rgd: The resource group descriptor
 *
 * Calculates bitmap descriptors, one for each block that contains bitmap data
 *
 * Returns: errno
 */

static int compute_bitstructs(struct gfs2_rgrpd *rgd)
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct gfs2_bitmap *bi;
755
	u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
756
	u32 bytes_left, bytes;
David Teigland's avatar
David Teigland committed
757
758
	int x;

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

762
	rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
David Teigland's avatar
David Teigland committed
763
764
765
	if (!rgd->rd_bits)
		return -ENOMEM;

766
	bytes_left = rgd->rd_bitbytes;
David Teigland's avatar
David Teigland committed
767
768
769
770

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

771
		bi->bi_flags = 0;
David Teigland's avatar
David Teigland committed
772
773
774
775
776
777
		/* small rgrp; bitmap stored completely in header block */
		if (length == 1) {
			bytes = bytes_left;
			bi->bi_offset = sizeof(struct gfs2_rgrp);
			bi->bi_start = 0;
			bi->bi_len = bytes;
778
			bi->bi_blocks = bytes * GFS2_NBBY;
David Teigland's avatar
David Teigland committed
779
780
781
782
783
784
		/* header block */
		} else if (x == 0) {
			bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
			bi->bi_offset = sizeof(struct gfs2_rgrp);
			bi->bi_start = 0;
			bi->bi_len = bytes;
785
			bi->bi_blocks = bytes * GFS2_NBBY;
David Teigland's avatar
David Teigland committed
786
787
788
789
		/* last block */
		} else if (x + 1 == length) {
			bytes = bytes_left;
			bi->bi_offset = sizeof(struct gfs2_meta_header);
790
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teigland's avatar
David Teigland committed
791
			bi->bi_len = bytes;
792
			bi->bi_blocks = bytes * GFS2_NBBY;
David Teigland's avatar
David Teigland committed
793
794
		/* other blocks */
		} else {
795
796
			bytes = sdp->sd_sb.sb_bsize -
				sizeof(struct gfs2_meta_header);
David Teigland's avatar
David Teigland committed
797
			bi->bi_offset = sizeof(struct gfs2_meta_header);
798
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teigland's avatar
David Teigland committed
799
			bi->bi_len = bytes;
800
			bi->bi_blocks = bytes * GFS2_NBBY;
David Teigland's avatar
David Teigland committed
801
802
803
804
805
806
807
808
809
810
		}

		bytes_left -= bytes;
	}

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

	return 0;
}

823
824
/**
 * gfs2_ri_total - Total up the file system space, according to the rindex.
825
 * @sdp: the filesystem
826
827
828
829
830
831
832
833
834
835
836
837
838
 *
 */
u64 gfs2_ri_total(struct gfs2_sbd *sdp)
{
	u64 total_data = 0;	
	struct inode *inode = sdp->sd_rindex;
	struct gfs2_inode *ip = GFS2_I(inode);
	char buf[sizeof(struct gfs2_rindex)];
	int error, rgrps;

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

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

Bob Peterson's avatar
Bob Peterson committed
850
static int rgd_insert(struct gfs2_rgrpd *rgd)
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct rb_node **newn = &sdp->sd_rindex_tree.rb_node, *parent = NULL;

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

		parent = *newn;
		if (rgd->rd_addr < cur->rd_addr)
			newn = &((*newn)->rb_left);
		else if (rgd->rd_addr > cur->rd_addr)
			newn = &((*newn)->rb_right);
		else
Bob Peterson's avatar
Bob Peterson committed
866
			return -EEXIST;
867
868
869
870
	}

	rb_link_node(&rgd->rd_node, parent, newn);
	rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
Bob Peterson's avatar
Bob Peterson committed
871
872
	sdp->sd_rgrps++;
	return 0;
873
874
}

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

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

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

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

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

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

	rgd->rd_sbd = sdp;
905
906
907
908
909
	rgd->rd_addr = be64_to_cpu(buf.ri_addr);
	rgd->rd_length = be32_to_cpu(buf.ri_length);
	rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
	rgd->rd_data = be32_to_cpu(buf.ri_data);
	rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
Bob Peterson's avatar
Bob Peterson committed
910
	spin_lock_init(&rgd->rd_rsspin);
911

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

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

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

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

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

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

948
static int gfs2_ri_update(struct gfs2_inode *ip)
David Teigland's avatar
David Teigland committed
949
{
950
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teigland's avatar
David Teigland committed
951
952
	int error;

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

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

960
	sdp->sd_rindex_uptodate = 1;
961
962
	return 0;
}
David Teigland's avatar
David Teigland committed
963
964

/**
965
 * gfs2_rindex_update - Update the rindex if required
David Teigland's avatar
David Teigland committed
966
967
968
969
970
971
972
973
974
975
976
977
 * @sdp: The GFS2 superblock
 *
 * We grab a lock on the rindex inode to make sure that it doesn't
 * change whilst we are performing an operation. We keep this lock
 * for quite long periods of time compared to other locks. This
 * doesn't matter, since it is shared and it is very, very rarely
 * accessed in the exclusive mode (i.e. only when expanding the filesystem).
 *
 * This makes sure that we're using the latest copy of the resource index
 * special file, which might have been updated if someone expanded the
 * filesystem (via gfs2_grow utility), which adds new resource groups.
 *
978
 * Returns: 0 on succeess, error code otherwise
David Teigland's avatar
David Teigland committed
979
980
 */

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

	/* Read new copy from disk if we don't have the latest */
990
	if (!sdp->sd_rindex_uptodate) {
991
992
993
		if (!gfs2_glock_is_locked_by_me(gl)) {
			error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, &ri_gh);
			if (error)
Bob Peterson's avatar
Bob Peterson committed
994
				return error;
995
996
			unlock_required = 1;
		}
997
		if (!sdp->sd_rindex_uptodate)
David Teigland's avatar
David Teigland committed
998
			error = gfs2_ri_update(ip);
999
1000
		if (unlock_required)
			gfs2_glock_dq_uninit(&ri_gh);
David Teigland's avatar
David Teigland committed
1001
1002
1003
1004
1005
	}

	return error;
}

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

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

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

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

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

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

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

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

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

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

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

	return count;
}


David Teigland's avatar
David Teigland committed
1088
/**
1089
1090
 * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
 * @rgd: the struct gfs2_rgrpd describing the RG to read in
David Teigland's avatar
David Teigland committed
1091
1092
1093
1094
1095
1096
1097
 *
 * Read in all of a Resource Group's header and bitmap blocks.
 * Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.
 *
 * Returns: errno
 */

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

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

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

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

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

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

	return error;
}

1163
1164
1165
1166
1167
1168