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

#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
14
#include <linux/fs.h>
15
#include <linux/gfs2_ondisk.h>
16
#include <linux/prefetch.h>
17
#include <linux/blkdev.h>
18
#include <linux/rbtree.h>
David Teigland's avatar
David Teigland committed
19
20

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

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

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

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

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

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

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

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

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

92
	BUG_ON(byte1 >= end);
93

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

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

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

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

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

	byte = buffer + (block / GFS2_NBBY);
	bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE;
	end = buffer + buflen;

	gfs2_assert(rgd->rd_sbd, byte < end);

	cur_state = (*byte >> bit) & GFS2_BIT_MASK;

	return cur_state;
}

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

static inline u64 gfs2_bit_search(const __le64 *ptr, u64 mask, u8 state)
{
	u64 tmp;
	static const u64 search[] = {
169
170
171
172
		[0] = 0xffffffffffffffffULL,
		[1] = 0xaaaaaaaaaaaaaaaaULL,
		[2] = 0x5555555555555555ULL,
		[3] = 0x0000000000000000ULL,
173
174
175
176
177
178
179
	};
	tmp = le64_to_cpu(*ptr) ^ search[state];
	tmp &= (tmp >> 1);
	tmp &= mask;
	return tmp;
}

180
181
182
/**
 * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
 *       a block in a given allocation state.
183
 * @buf: the buffer that holds the bitmaps
184
 * @len: the length (in bytes) of the buffer
185
 * @goal: start search at this block's bit-pair (within @buffer)
186
 * @state: GFS2_BLKST_XXX the state of the block we're looking for.
187
188
189
 *
 * Scope of @goal and returned block number is only within this bitmap buffer,
 * not entire rgrp or filesystem.  @buffer will be offset from the actual
190
191
192
193
194
 * beginning of a bitmap block buffer, skipping any header structures, but
 * headers are always a multiple of 64 bits long so that the buffer is
 * always aligned to a 64 bit boundary.
 *
 * The size of the buffer is in bytes, but is it assumed that it is
195
 * always ok to read a complete multiple of 64 bits at the end
196
 * of the block in case the end is no aligned to a natural boundary.
197
198
199
200
 *
 * Return: the block number (bitmap buffer scope) that was found
 */

201
202
static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
		       u32 goal, u8 state)
203
{
204
205
206
207
	u32 spoint = (goal << 1) & ((8*sizeof(u64)) - 1);
	const __le64 *ptr = ((__le64 *)buf) + (goal >> 5);
	const __le64 *end = (__le64 *)(buf + ALIGN(len, sizeof(u64)));
	u64 tmp;
208
	u64 mask = 0x5555555555555555ULL;
209
210
211
212
213
214
215
216
217
	u32 bit;

	BUG_ON(state > 3);

	/* Mask off bits we don't care about at the start of the search */
	mask <<= spoint;
	tmp = gfs2_bit_search(ptr, mask, state);
	ptr++;
	while(tmp == 0 && ptr < end) {
218
		tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
219
		ptr++;
220
	}
221
222
223
224
225
226
227
	/* Mask off any bits which are more than len bytes from the start */
	if (ptr == end && (len & (sizeof(u64) - 1)))
		tmp &= (((u64)~0) >> (64 - 8*(len & (sizeof(u64) - 1))));
	/* Didn't find anything, so return */
	if (tmp == 0)
		return BFITNOENT;
	ptr--;
228
	bit = __ffs64(tmp);
229
230
	bit /= 2;	/* two bits per entry in the bitmap */
	return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
231
232
233
234
}

/**
 * gfs2_bitcount - count the number of bits in a certain state
235
 * @rgd: the resource group descriptor
236
237
238
239
240
241
242
 * @buffer: the buffer that holds the bitmaps
 * @buflen: the length (in bytes) of the buffer
 * @state: the state of the block we're looking for
 *
 * Returns: The number of bits
 */

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

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

	return count;
}

David Teigland's avatar
David Teigland committed
267
268
269
270
271
272
273
274
275
276
/**
 * gfs2_rgrp_verify - Verify that a resource group is consistent
 * @rgd: the rgrp
 *
 */

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

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

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

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

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

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

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

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

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

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

	return NULL;
}

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

struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp)
{
372
373
374
	const struct rb_node *n;
	struct gfs2_rgrpd *rgd;

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

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

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

struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
{
392
393
394
395
396
397
398
399
400
401
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	const struct rb_node *n;

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

	if (unlikely(&rgd->rd_node == n)) {
		spin_unlock(&sdp->sd_rindex_spin);
David Teigland's avatar
David Teigland committed
402
		return NULL;
403
404
405
406
	}
	rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
	spin_unlock(&sdp->sd_rindex_spin);
	return rgd;
David Teigland's avatar
David Teigland committed
407
408
}

409
410
411
412
413
414
415
416
417
418
419
void gfs2_free_clones(struct gfs2_rgrpd *rgd)
{
	int x;

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

420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
/**
 * gfs2_rs_alloc - make sure we have a reservation assigned to the inode
 * @ip: the inode for this reservation
 */
int gfs2_rs_alloc(struct gfs2_inode *ip)
{
	int error = 0;

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

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

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

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

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

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

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

479
480
481
482
483
484
485
486
487
static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd)
{
	printk(KERN_INFO "  ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
	printk(KERN_INFO "  ri_length = %u\n", rgd->rd_length);
	printk(KERN_INFO "  ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
	printk(KERN_INFO "  ri_data = %u\n", rgd->rd_data);
	printk(KERN_INFO "  ri_bitbytes = %u\n", rgd->rd_bitbytes);
}

David Teigland's avatar
David Teigland committed
488
489
490
491
492
493
494
495
496
497
498
499
500
/**
 * gfs2_compute_bitstructs - Compute the bitmap sizes
 * @rgd: The resource group descriptor
 *
 * Calculates bitmap descriptors, one for each block that contains bitmap data
 *
 * Returns: errno
 */

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

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

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

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

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

517
		bi->bi_flags = 0;
David Teigland's avatar
David Teigland committed
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
		/* small rgrp; bitmap stored completely in header block */
		if (length == 1) {
			bytes = bytes_left;
			bi->bi_offset = sizeof(struct gfs2_rgrp);
			bi->bi_start = 0;
			bi->bi_len = bytes;
		/* header block */
		} else if (x == 0) {
			bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
			bi->bi_offset = sizeof(struct gfs2_rgrp);
			bi->bi_start = 0;
			bi->bi_len = bytes;
		/* last block */
		} else if (x + 1 == length) {
			bytes = bytes_left;
			bi->bi_offset = sizeof(struct gfs2_meta_header);
534
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teigland's avatar
David Teigland committed
535
536
537
			bi->bi_len = bytes;
		/* other blocks */
		} else {
538
539
			bytes = sdp->sd_sb.sb_bsize -
				sizeof(struct gfs2_meta_header);
David Teigland's avatar
David Teigland committed
540
			bi->bi_offset = sizeof(struct gfs2_meta_header);
541
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teigland's avatar
David Teigland committed
542
543
544
545
546
547
548
549
550
551
552
			bi->bi_len = bytes;
		}

		bytes_left -= bytes;
	}

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

	return 0;
}

565
566
/**
 * gfs2_ri_total - Total up the file system space, according to the rindex.
567
 * @sdp: the filesystem
568
569
570
571
572
573
574
575
576
577
578
579
580
 *
 */
u64 gfs2_ri_total(struct gfs2_sbd *sdp)
{
	u64 total_data = 0;	
	struct inode *inode = sdp->sd_rindex;
	struct gfs2_inode *ip = GFS2_I(inode);
	char buf[sizeof(struct gfs2_rindex)];
	int error, rgrps;

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

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

Bob Peterson's avatar
Bob Peterson committed
592
static int rgd_insert(struct gfs2_rgrpd *rgd)
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct rb_node **newn = &sdp->sd_rindex_tree.rb_node, *parent = NULL;

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

		parent = *newn;
		if (rgd->rd_addr < cur->rd_addr)
			newn = &((*newn)->rb_left);
		else if (rgd->rd_addr > cur->rd_addr)
			newn = &((*newn)->rb_right);
		else
Bob Peterson's avatar
Bob Peterson committed
608
			return -EEXIST;
609
610
611
612
	}

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

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

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

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

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

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

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

	rgd->rd_sbd = sdp;
647
648
649
650
651
	rgd->rd_addr = be64_to_cpu(buf.ri_addr);
	rgd->rd_length = be32_to_cpu(buf.ri_length);
	rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
	rgd->rd_data = be32_to_cpu(buf.ri_data);
	rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
652

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

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

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

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

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

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

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

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

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

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

/**
706
 * gfs2_rindex_update - Update the rindex if required
David Teigland's avatar
David Teigland committed
707
708
709
710
711
712
713
714
715
716
717
718
 * @sdp: The GFS2 superblock
 *
 * We grab a lock on the rindex inode to make sure that it doesn't
 * change whilst we are performing an operation. We keep this lock
 * for quite long periods of time compared to other locks. This
 * doesn't matter, since it is shared and it is very, very rarely
 * accessed in the exclusive mode (i.e. only when expanding the filesystem).
 *
 * This makes sure that we're using the latest copy of the resource index
 * special file, which might have been updated if someone expanded the
 * filesystem (via gfs2_grow utility), which adds new resource groups.
 *
719
 * Returns: 0 on succeess, error code otherwise
David Teigland's avatar
David Teigland committed
720
721
 */

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

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

	return error;
}

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

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

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

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

773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
{
	struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
	struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;

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

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

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

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

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

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

	return count;
}


David Teigland's avatar
David Teigland committed
829
/**
830
831
 * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
 * @rgd: the struct gfs2_rgrpd describing the RG to read in
David Teigland's avatar
David Teigland committed
832
833
834
835
836
837
838
 *
 * Read in all of a Resource Group's header and bitmap blocks.
 * Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.
 *
 * Returns: errno
 */

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

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

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

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

870
	if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
871
872
		for (x = 0; x < length; x++)
			clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
873
		gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
874
		rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
875
		rgd->rd_free_clone = rgd->rd_free;
David Teigland's avatar
David Teigland committed
876
	}
877
878
879
880
881
882
883
884
885
886
887
888
889
890
	if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
		rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
		gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
				     rgd->rd_bits[0].bi_bh->b_data);
	}
	else if (sdp->sd_args.ar_rgrplvb) {
		if (!gfs2_rgrp_lvb_valid(rgd)){
			gfs2_consist_rgrpd(rgd);
			error = -EIO;
			goto fail;
		}
		if (rgd->rd_rgl->rl_unlinked == 0)
			rgd->rd_flags &= ~GFS2_RDF_CHECK;
	}
David Teigland's avatar
David Teigland committed
891
892
	return 0;

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

	return error;
}

904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
{
	u32 rl_flags;

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

	if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
		return gfs2_rgrp_bh_get(rgd);

	rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
	rl_flags &= ~GFS2_RDF_MASK;
	rgd->rd_flags &= GFS2_RDF_MASK;
	rgd->rd_flags |= (rl_flags | GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
	if (rgd->rd_rgl->rl_unlinked == 0)
		rgd->rd_flags &= ~GFS2_RDF_CHECK;
	rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
	rgd->rd_free_clone = rgd->rd_free;
	rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
	rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
	return 0;
}

int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
{
	struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
	struct gfs2_sbd *sdp = rgd->rd_sbd;

	if (gh->gh_flags & GL_SKIP && sdp->sd_args.ar_rgrplvb)
		return 0;
	return gfs2_rgrp_bh_get((struct gfs2_rgrpd *)gh->gh_gl->gl_object);
}

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

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

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

}

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

	for (x = 0; x < bi->bi_len; x++) {
Steven Whitehouse's avatar
Steven Whitehouse committed
975
976
977
978
979
980
981
982
983
		const u8 *clone = bi->bi_clone ? bi->bi_clone : bi->bi_bh->b_data;
		clone += bi->bi_offset;
		clone += x;
		if (bh) {
			const u8 *orig = bh->b_data + bi->bi_offset + x;
			diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));
		} else {
			diff = ~(*clone | (*clone >> 1));
		}
984
985
986
987
988
989
990
991
992
993
		diff &= 0x55;
		if (diff == 0)
			continue;
		blk = offset + ((bi->bi_start + x) * GFS2_NBBY);
		blk *= sects_per_blk; /* convert to sectors */
		while(diff) {
			if (diff & 1) {
				if (nr_sects == 0)
					goto start_new_extent;
				if ((start + nr_sects) != blk) {
Steven Whitehouse's avatar
Steven Whitehouse committed
994
995
996
997
998
999
1000
					if (nr_sects >= minlen) {
						rv = blkdev_issue_discard(bdev,
							start, nr_sects,
							GFP_NOFS, 0);
						if (rv)
							goto fail;
						trimmed += nr_sects;