rgrp.c 60 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

Bob Peterson's avatar
Bob Peterson committed
38
39
40
#define RSRV_CONTENTION_FACTOR 4
#define RGRP_RSRV_MAX_CONTENDERS 2

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

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

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

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

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

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

91
	BUG_ON(byte1 >= end);
92

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

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

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

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

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

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

Bob Peterson's avatar
Bob Peterson committed
179
180
181
182
183
184
185
186
187
188
189
190
/**
 * 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)
{
191
	u64 startblk = gfs2_rbm_to_block(&rs->rs_rbm);
Bob Peterson's avatar
Bob Peterson committed
192
193
194
195
196
197
198
199

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

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

221
222
static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
		       u32 goal, u8 state)
223
{
224
225
226
227
	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;
228
	u64 mask = 0x5555555555555555ULL;
229
230
231
232
233
234
235
236
237
	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) {
238
		tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
239
		ptr++;
240
	}
241
242
243
244
245
246
247
	/* 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--;
248
	bit = __ffs64(tmp);
249
250
	bit /= 2;	/* two bits per entry in the bitmap */
	return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
251
252
253
254
}

/**
 * gfs2_bitcount - count the number of bits in a certain state
255
 * @rgd: the resource group descriptor
256
257
258
259
260
261
262
 * @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
 */

263
264
static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
			 unsigned int buflen, u8 state)
265
{
266
267
268
269
270
	const u8 *byte = buffer;
	const u8 *end = buffer + buflen;
	const u8 state1 = state << 2;
	const u8 state2 = state << 4;
	const u8 state3 = state << 6;
271
	u32 count = 0;
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286

	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
287
288
289
290
291
292
293
294
295
296
/**
 * 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;
297
	u32 length = rgd->rd_length;
298
	u32 count[4], tmp;
David Teigland's avatar
David Teigland committed
299
300
	int buf, x;

301
	memset(count, 0, 4 * sizeof(u32));
David Teigland's avatar
David Teigland committed
302
303
304
305
306
307
308
309
310
311
312

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

313
	if (count[0] != rgd->rd_free) {
David Teigland's avatar
David Teigland committed
314
315
		if (gfs2_consist_rgrpd(rgd))
			fs_err(sdp, "free data mismatch:  %u != %u\n",
316
			       count[0], rgd->rd_free);
David Teigland's avatar
David Teigland committed
317
318
319
		return;
	}

320
	tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
321
	if (count[1] != tmp) {
David Teigland's avatar
David Teigland committed
322
323
324
325
326
327
		if (gfs2_consist_rgrpd(rgd))
			fs_err(sdp, "used data mismatch:  %u != %u\n",
			       count[1], tmp);
		return;
	}

328
	if (count[2] + count[3] != rgd->rd_dinodes) {
David Teigland's avatar
David Teigland committed
329
		if (gfs2_consist_rgrpd(rgd))
330
			fs_err(sdp, "used metadata mismatch:  %u != %u\n",
331
			       count[2] + count[3], rgd->rd_dinodes);
David Teigland's avatar
David Teigland committed
332
333
334
335
		return;
	}
}

336
static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block)
David Teigland's avatar
David Teigland committed
337
{
338
339
	u64 first = rgd->rd_data0;
	u64 last = first + rgd->rd_data;
340
	return first <= block && block < last;
David Teigland's avatar
David Teigland committed
341
342
343
344
345
}

/**
 * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
 * @sdp: The GFS2 superblock
346
347
 * @blk: The data block number
 * @exact: True if this needs to be an exact match
David Teigland's avatar
David Teigland committed
348
349
350
351
 *
 * Returns: The resource group, or NULL if not found
 */

Steven Whitehouse's avatar
Steven Whitehouse committed
352
struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
David Teigland's avatar
David Teigland committed
353
{
Steven Whitehouse's avatar
Steven Whitehouse committed
354
	struct rb_node *n, *next;
355
	struct gfs2_rgrpd *cur;
David Teigland's avatar
David Teigland committed
356
357

	spin_lock(&sdp->sd_rindex_spin);
Steven Whitehouse's avatar
Steven Whitehouse committed
358
359
360
361
	n = sdp->sd_rindex_tree.rb_node;
	while (n) {
		cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
		next = NULL;
362
		if (blk < cur->rd_addr)
Steven Whitehouse's avatar
Steven Whitehouse committed
363
			next = n->rb_left;
364
		else if (blk >= cur->rd_data0 + cur->rd_data)
Steven Whitehouse's avatar
Steven Whitehouse committed
365
366
			next = n->rb_right;
		if (next == NULL) {
David Teigland's avatar
David Teigland committed
367
			spin_unlock(&sdp->sd_rindex_spin);
Steven Whitehouse's avatar
Steven Whitehouse committed
368
369
370
371
372
373
			if (exact) {
				if (blk < cur->rd_addr)
					return NULL;
				if (blk >= cur->rd_data0 + cur->rd_data)
					return NULL;
			}
374
			return cur;
David Teigland's avatar
David Teigland committed
375
		}
Steven Whitehouse's avatar
Steven Whitehouse committed
376
		n = next;
David Teigland's avatar
David Teigland committed
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
	}
	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)
{
392
393
394
	const struct rb_node *n;
	struct gfs2_rgrpd *rgd;

395
	spin_lock(&sdp->sd_rindex_spin);
396
397
	n = rb_first(&sdp->sd_rindex_tree);
	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
398
	spin_unlock(&sdp->sd_rindex_spin);
399
400

	return rgd;
David Teigland's avatar
David Teigland committed
401
402
403
404
}

/**
 * gfs2_rgrpd_get_next - get the next RG
405
 * @rgd: the resource group descriptor
David Teigland's avatar
David Teigland committed
406
407
408
409
410
411
 *
 * Returns: The next rgrp
 */

struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
{
412
413
414
415
416
417
418
419
420
421
	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
422
		return NULL;
423
424
425
426
	}
	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
	spin_unlock(&sdp->sd_rindex_spin);
	return rgd;
David Teigland's avatar
David Teigland committed
427
428
}

429
430
431
432
433
434
435
436
437
438
439
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;
	}
}

440
441
442
443
444
445
446
/**
 * 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;
Bob Peterson's avatar
Bob Peterson committed
447
448
449
450
451
452
453
454
	struct gfs2_blkreserv *res;

	if (ip->i_res)
		return 0;

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

456
457
	rb_init_node(&res->rs_node);

458
	down_write(&ip->i_rw_mutex);
Bob Peterson's avatar
Bob Peterson committed
459
460
461
462
	if (ip->i_res)
		kmem_cache_free(gfs2_rsrv_cachep, res);
	else
		ip->i_res = res;
463
464
465
466
	up_write(&ip->i_rw_mutex);
	return error;
}

Bob Peterson's avatar
Bob Peterson committed
467
468
469
static void dump_rs(struct seq_file *seq, struct gfs2_blkreserv *rs)
{
	gfs2_print_dbg(seq, "  r: %llu s:%llu b:%u f:%u\n",
470
471
		       rs->rs_rbm.rgd->rd_addr, gfs2_rbm_to_block(&rs->rs_rbm), 
		       rs->rs_rbm.offset, rs->rs_free);
Bob Peterson's avatar
Bob Peterson committed
472
473
}

474
/**
Bob Peterson's avatar
Bob Peterson committed
475
476
477
478
 * __rs_deltree - remove a multi-block reservation from the rgd tree
 * @rs: The reservation to remove
 *
 */
479
static void __rs_deltree(struct gfs2_inode *ip, struct gfs2_blkreserv *rs)
Bob Peterson's avatar
Bob Peterson committed
480
481
482
483
484
485
{
	struct gfs2_rgrpd *rgd;

	if (!gfs2_rs_active(rs))
		return;

486
487
488
489
	rgd = rs->rs_rbm.rgd;
	trace_gfs2_rs(ip, rs, TRACE_RS_TREEDEL);
	rb_erase(&rs->rs_node, &rgd->rd_rstree);
	rb_init_node(&rs->rs_node);
Bob Peterson's avatar
Bob Peterson committed
490
491
492
493
494
	BUG_ON(!rgd->rd_rs_cnt);
	rgd->rd_rs_cnt--;

	if (rs->rs_free) {
		/* return reserved blocks to the rgrp and the ip */
495
496
		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
497
		rs->rs_free = 0;
498
		clear_bit(GBF_FULL, &rs->rs_rbm.bi->bi_flags);
Bob Peterson's avatar
Bob Peterson committed
499
500
501
502
503
504
505
506
507
		smp_mb__after_clear_bit();
	}
}

/**
 * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
 * @rs: The reservation to remove
 *
 */
508
void gfs2_rs_deltree(struct gfs2_inode *ip, struct gfs2_blkreserv *rs)
Bob Peterson's avatar
Bob Peterson committed
509
510
511
{
	struct gfs2_rgrpd *rgd;

512
513
514
515
516
517
	rgd = rs->rs_rbm.rgd;
	if (rgd) {
		spin_lock(&rgd->rd_rsspin);
		__rs_deltree(ip, rs);
		spin_unlock(&rgd->rd_rsspin);
	}
Bob Peterson's avatar
Bob Peterson committed
518
519
520
521
}

/**
 * gfs2_rs_delete - delete a multi-block reservation
522
523
524
525
526
527
528
 * @ip: The inode for this reservation
 *
 */
void gfs2_rs_delete(struct gfs2_inode *ip)
{
	down_write(&ip->i_rw_mutex);
	if (ip->i_res) {
529
		gfs2_rs_deltree(ip, ip->i_res);
Bob Peterson's avatar
Bob Peterson committed
530
531
		trace_gfs2_rs(ip, ip->i_res, TRACE_RS_DELETE);
		BUG_ON(ip->i_res->rs_free);
532
533
534
535
536
537
		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
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
/**
 * 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);
554
		__rs_deltree(NULL, rs);
Bob Peterson's avatar
Bob Peterson committed
555
556
557
558
	}
	spin_unlock(&rgd->rd_rsspin);
}

559
void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
David Teigland's avatar
David Teigland committed
560
{
561
	struct rb_node *n;
David Teigland's avatar
David Teigland committed
562
563
564
	struct gfs2_rgrpd *rgd;
	struct gfs2_glock *gl;

565
566
	while ((n = rb_first(&sdp->sd_rindex_tree))) {
		rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
David Teigland's avatar
David Teigland committed
567
568
		gl = rgd->rd_gl;

569
		rb_erase(n, &sdp->sd_rindex_tree);
David Teigland's avatar
David Teigland committed
570
571

		if (gl) {
572
			spin_lock(&gl->gl_spin);
573
			gl->gl_object = NULL;
574
			spin_unlock(&gl->gl_spin);
575
			gfs2_glock_add_to_lru(gl);
David Teigland's avatar
David Teigland committed
576
577
578
			gfs2_glock_put(gl);
		}

579
		gfs2_free_clones(rgd);
David Teigland's avatar
David Teigland committed
580
		kfree(rgd->rd_bits);
Bob Peterson's avatar
Bob Peterson committed
581
		return_all_reservations(rgd);
582
		kmem_cache_free(gfs2_rgrpd_cachep, rgd);
David Teigland's avatar
David Teigland committed
583
584
585
	}
}

586
587
588
589
590
591
592
593
594
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
595
596
597
598
599
600
601
602
603
604
605
606
607
/**
 * 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;
608
	u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
609
	u32 bytes_left, bytes;
David Teigland's avatar
David Teigland committed
610
611
	int x;

612
613
614
	if (!length)
		return -EINVAL;

615
	rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
David Teigland's avatar
David Teigland committed
616
617
618
	if (!rgd->rd_bits)
		return -ENOMEM;

619
	bytes_left = rgd->rd_bitbytes;
David Teigland's avatar
David Teigland committed
620
621
622
623

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

624
		bi->bi_flags = 0;
David Teigland's avatar
David Teigland committed
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
		/* 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);
641
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teigland's avatar
David Teigland committed
642
643
644
			bi->bi_len = bytes;
		/* other blocks */
		} else {
645
646
			bytes = sdp->sd_sb.sb_bsize -
				sizeof(struct gfs2_meta_header);
David Teigland's avatar
David Teigland committed
647
			bi->bi_offset = sizeof(struct gfs2_meta_header);
648
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teigland's avatar
David Teigland committed
649
650
651
652
653
654
655
656
657
658
659
			bi->bi_len = bytes;
		}

		bytes_left -= bytes;
	}

	if (bytes_left) {
		gfs2_consist_rgrpd(rgd);
		return -EIO;
	}
	bi = rgd->rd_bits + (length - 1);
660
	if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
David Teigland's avatar
David Teigland committed
661
		if (gfs2_consist_rgrpd(rgd)) {
662
			gfs2_rindex_print(rgd);
David Teigland's avatar
David Teigland committed
663
664
665
666
667
668
669
670
671
			fs_err(sdp, "start=%u len=%u offset=%u\n",
			       bi->bi_start, bi->bi_len, bi->bi_offset);
		}
		return -EIO;
	}

	return 0;
}

672
673
/**
 * gfs2_ri_total - Total up the file system space, according to the rindex.
674
 * @sdp: the filesystem
675
676
677
678
679
680
681
682
683
684
685
686
687
 *
 */
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);

688
		if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
689
			break;
690
		error = gfs2_internal_read(ip, buf, &pos,
691
692
693
					   sizeof(struct gfs2_rindex));
		if (error != sizeof(struct gfs2_rindex))
			break;
694
		total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
695
696
697
698
	}
	return total_data;
}

Bob Peterson's avatar
Bob Peterson committed
699
static int rgd_insert(struct gfs2_rgrpd *rgd)
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
{
	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
715
			return -EEXIST;
716
717
718
719
	}

	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
720
721
	sdp->sd_rgrps++;
	return 0;
722
723
}

David Teigland's avatar
David Teigland committed
724
/**
725
 * read_rindex_entry - Pull in a new resource index entry from the disk
726
 * @ip: Pointer to the rindex inode
David Teigland's avatar
David Teigland committed
727
 *
728
 * Returns: 0 on success, > 0 on EOF, error code otherwise
729
730
 */

731
static int read_rindex_entry(struct gfs2_inode *ip)
732
733
734
{
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
735
	struct gfs2_rindex buf;
736
737
738
	int error;
	struct gfs2_rgrpd *rgd;

739
740
741
	if (pos >= i_size_read(&ip->i_inode))
		return 1;

742
	error = gfs2_internal_read(ip, (char *)&buf, &pos,
743
				   sizeof(struct gfs2_rindex));
744
745
746

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

748
	rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
749
750
751
752
753
	error = -ENOMEM;
	if (!rgd)
		return error;

	rgd->rd_sbd = sdp;
754
755
756
757
758
	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
759
	spin_lock_init(&rgd->rd_rsspin);
760

761
762
	error = compute_bitstructs(rgd);
	if (error)
763
		goto fail;
764

765
	error = gfs2_glock_get(sdp, rgd->rd_addr,
766
767
			       &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
	if (error)
768
		goto fail;
769
770

	rgd->rd_gl->gl_object = rgd;
771
	rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lvb;
772
	rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
773
774
	if (rgd->rd_data > sdp->sd_max_rg_data)
		sdp->sd_max_rg_data = rgd->rd_data;
775
	spin_lock(&sdp->sd_rindex_spin);
Bob Peterson's avatar
Bob Peterson committed
776
	error = rgd_insert(rgd);
777
	spin_unlock(&sdp->sd_rindex_spin);
Bob Peterson's avatar
Bob Peterson committed
778
779
780
781
	if (!error)
		return 0;

	error = 0; /* someone else read in the rgrp; free it and ignore it */
782
	gfs2_glock_put(rgd->rd_gl);
783
784
785
786

fail:
	kfree(rgd->rd_bits);
	kmem_cache_free(gfs2_rgrpd_cachep, rgd);
787
788
789
790
791
792
793
	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
794
795
796
 * Returns: 0 on successful update, error code otherwise
 */

797
static int gfs2_ri_update(struct gfs2_inode *ip)
David Teigland's avatar
David Teigland committed
798
{
799
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teigland's avatar
David Teigland committed
800
801
	int error;

802
	do {
803
		error = read_rindex_entry(ip);
804
805
806
807
	} while (error == 0);

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

809
	sdp->sd_rindex_uptodate = 1;
810
811
	return 0;
}
David Teigland's avatar
David Teigland committed
812
813

/**
814
 * gfs2_rindex_update - Update the rindex if required
David Teigland's avatar
David Teigland committed
815
816
817
818
819
820
821
822
823
824
825
826
 * @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.
 *
827
 * Returns: 0 on succeess, error code otherwise
David Teigland's avatar
David Teigland committed
828
829
 */

830
int gfs2_rindex_update(struct gfs2_sbd *sdp)
David Teigland's avatar
David Teigland committed
831
{
832
	struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
David Teigland's avatar
David Teigland committed
833
	struct gfs2_glock *gl = ip->i_gl;
834
835
	struct gfs2_holder ri_gh;
	int error = 0;
836
	int unlock_required = 0;
David Teigland's avatar
David Teigland committed
837
838

	/* Read new copy from disk if we don't have the latest */
839
	if (!sdp->sd_rindex_uptodate) {
840
841
842
		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
843
				return error;
844
845
			unlock_required = 1;
		}
846
		if (!sdp->sd_rindex_uptodate)
David Teigland's avatar
David Teigland committed
847
			error = gfs2_ri_update(ip);
848
849
		if (unlock_required)
			gfs2_glock_dq_uninit(&ri_gh);
David Teigland's avatar
David Teigland committed
850
851
852
853
854
	}

	return error;
}

855
static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
856
857
{
	const struct gfs2_rgrp *str = buf;
858
	u32 rg_flags;
859

860
	rg_flags = be32_to_cpu(str->rg_flags);
861
	rg_flags &= ~GFS2_RDF_MASK;
862
863
	rgd->rd_flags &= GFS2_RDF_MASK;
	rgd->rd_flags |= rg_flags;
864
	rgd->rd_free = be32_to_cpu(str->rg_free);
865
	rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
866
	rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
867
868
}

869
static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
870
871
872
{
	struct gfs2_rgrp *str = buf;

873
	str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
874
	str->rg_free = cpu_to_be32(rgd->rd_free);
875
	str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
876
	str->__pad = cpu_to_be32(0);
877
	str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
878
879
880
	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
}

881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
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
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
937
/**
938
939
 * 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
940
941
942
943
944
945
946
 *
 * 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
 */

947
int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
David Teigland's avatar
David Teigland committed
948
949
950
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct gfs2_glock *gl = rgd->rd_gl;
951
	unsigned int length = rgd->rd_length;
David Teigland's avatar
David Teigland committed
952
953
954
955
	struct gfs2_bitmap *bi;
	unsigned int x, y;
	int error;

956
957
958
	if (rgd->rd_bits[0].bi_bh != NULL)
		return 0;

David Teigland's avatar
David Teigland committed
959
960
	for (x = 0; x < length; x++) {
		bi = rgd->rd_bits + x;
961
		error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
David Teigland's avatar
David Teigland committed
962
963
964
965
966
967
		if (error)
			goto fail;
	}

	for (y = length; y--;) {
		bi = rgd->rd_bits + y;
968
		error = gfs2_meta_wait(sdp, bi->bi_bh);
David Teigland's avatar
David Teigland committed
969
970
		if (error)
			goto fail;
971
		if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
David Teigland's avatar
David Teigland committed
972
973
974
975
976
977
					      GFS2_METATYPE_RG)) {
			error = -EIO;
			goto fail;
		}
	}

978
	if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
979
980
		for (x = 0; x < length; x++)
			clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
981
		gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
982
		rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
983
		rgd->rd_free_clone = rgd->rd_free;
David Teigland's avatar
David Teigland committed
984
	}
985
986
987
988
989
990
991
992
993
994
995
996
997
998
	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
999
1000
	return 0;