rgrp.c 46.9 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>
David Teigland's avatar
David Teigland committed
18
19

#include "gfs2.h"
20
#include "incore.h"
David Teigland's avatar
David Teigland committed
21
22
23
24
25
26
27
28
#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"
29
#include "util.h"
30
#include "log.h"
31
#include "inode.h"
Steven Whitehouse's avatar
Steven Whitehouse committed
32
#include "trace_gfs2.h"
David Teigland's avatar
David Teigland committed
33

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

37
38
39
40
41
42
43
44
45
46
#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

47
48
49
/*
 * These routines are used by the resource group routines (rgrp.c)
 * to keep track of block allocation.  Each block is represented by two
50
51
52
53
54
55
 * 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)
56
57
58
59
 */

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

66
static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
67
68
                        unsigned char old_state, unsigned char new_state,
			unsigned int *n);
69

70
71
72
73
74
75
76
77
78
/**
 * gfs2_setbit - Set a bit in the bitmaps
 * @buffer: the buffer that holds the bitmaps
 * @buflen: the length (in bytes) of the buffer
 * @block: the block to set
 * @new_state: the new state of the block
 *
 */

79
80
static inline void gfs2_setbit(struct gfs2_rgrpd *rgd, unsigned char *buf1,
			       unsigned char *buf2, unsigned int offset,
81
			       struct gfs2_bitmap *bi, u32 block,
82
			       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 = buf1 + offset + (block / GFS2_NBBY);
	end = buf1 + 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
112
113
114
115
		return;
	}
	*byte1 ^= (cur_state ^ new_state) << bit;

	if (buf2) {
		byte2 = buf2 + offset + (block / GFS2_NBBY);
		cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
		*byte2 ^= (cur_state ^ new_state) << bit;
	}
116
117
118
119
120
121
122
123
124
125
}

/**
 * gfs2_testbit - test a bit in the bitmaps
 * @buffer: the buffer that holds the bitmaps
 * @buflen: the length (in bytes) of the buffer
 * @block: the block to read
 *
 */

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

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

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

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

/**
 * gfs2_bitcount - count the number of bits in a certain state
 * @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
 */

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

	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
264
265
266
267
268
269
270
271
272
273
274
/**
 * gfs2_rgrp_verify - Verify that a resource group is consistent
 * @sdp: the filesystem
 * @rgd: the rgrp
 *
 */

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

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

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

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

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

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

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

/**
 * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
 * @sdp: The GFS2 superblock
 * @n: The data block number
 *
 * Returns: The resource group, or NULL if not found
 */

329
struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk)
David Teigland's avatar
David Teigland committed
330
331
332
333
334
335
{
	struct gfs2_rgrpd *rgd;

	spin_lock(&sdp->sd_rindex_spin);

	list_for_each_entry(rgd, &sdp->sd_rindex_mru_list, rd_list_mru) {
336
		if (rgrp_contains_block(rgd, blk)) {
David Teigland's avatar
David Teigland committed
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
			list_move(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);
			spin_unlock(&sdp->sd_rindex_spin);
			return rgd;
		}
	}

	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)
{
	gfs2_assert(sdp, !list_empty(&sdp->sd_rindex_list));
	return list_entry(sdp->sd_rindex_list.next, struct gfs2_rgrpd, rd_list);
}

/**
 * gfs2_rgrpd_get_next - get the next RG
 * @rgd: A RG
 *
 * Returns: The next rgrp
 */

struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
{
	if (rgd->rd_list.next == &rgd->rd_sbd->sd_rindex_list)
		return NULL;
	return list_entry(rgd->rd_list.next, struct gfs2_rgrpd, rd_list);
}

static void clear_rgrpdi(struct gfs2_sbd *sdp)
{
	struct list_head *head;
	struct gfs2_rgrpd *rgd;
	struct gfs2_glock *gl;

	spin_lock(&sdp->sd_rindex_spin);
	sdp->sd_rindex_forward = NULL;
	spin_unlock(&sdp->sd_rindex_spin);

	head = &sdp->sd_rindex_list;
	while (!list_empty(head)) {
		rgd = list_entry(head->next, struct gfs2_rgrpd, rd_list);
		gl = rgd->rd_gl;

		list_del(&rgd->rd_list);
		list_del(&rgd->rd_list_mru);

		if (gl) {
394
			gl->gl_object = NULL;
395
			gfs2_glock_add_to_lru(gl);
David Teigland's avatar
David Teigland committed
396
397
398
399
			gfs2_glock_put(gl);
		}

		kfree(rgd->rd_bits);
400
		kmem_cache_free(gfs2_rgrpd_cachep, rgd);
David Teigland's avatar
David Teigland committed
401
402
403
404
405
	}
}

void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
{
406
	mutex_lock(&sdp->sd_rindex_mutex);
David Teigland's avatar
David Teigland committed
407
	clear_rgrpdi(sdp);
408
	mutex_unlock(&sdp->sd_rindex_mutex);
David Teigland's avatar
David Teigland committed
409
410
}

411
412
413
414
415
416
417
418
419
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
420
421
422
423
424
425
426
427
428
429
430
431
432
/**
 * 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;
433
	u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
434
	u32 bytes_left, bytes;
David Teigland's avatar
David Teigland committed
435
436
	int x;

437
438
439
	if (!length)
		return -EINVAL;

440
	rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
David Teigland's avatar
David Teigland committed
441
442
443
	if (!rgd->rd_bits)
		return -ENOMEM;

444
	bytes_left = rgd->rd_bitbytes;
David Teigland's avatar
David Teigland committed
445
446
447
448

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

449
		bi->bi_flags = 0;
David Teigland's avatar
David Teigland committed
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
		/* 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);
466
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teigland's avatar
David Teigland committed
467
468
469
			bi->bi_len = bytes;
		/* other blocks */
		} else {
470
471
			bytes = sdp->sd_sb.sb_bsize -
				sizeof(struct gfs2_meta_header);
David Teigland's avatar
David Teigland committed
472
			bi->bi_offset = sizeof(struct gfs2_meta_header);
473
			bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teigland's avatar
David Teigland committed
474
475
476
477
478
479
480
481
482
483
484
			bi->bi_len = bytes;
		}

		bytes_left -= bytes;
	}

	if (bytes_left) {
		gfs2_consist_rgrpd(rgd);
		return -EIO;
	}
	bi = rgd->rd_bits + (length - 1);
485
	if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
David Teigland's avatar
David Teigland committed
486
		if (gfs2_consist_rgrpd(rgd)) {
487
			gfs2_rindex_print(rgd);
David Teigland's avatar
David Teigland committed
488
489
490
491
492
493
494
495
496
			fs_err(sdp, "start=%u len=%u offset=%u\n",
			       bi->bi_start, bi->bi_len, bi->bi_offset);
		}
		return -EIO;
	}

	return 0;
}

497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
/**
 * gfs2_ri_total - Total up the file system space, according to the rindex.
 *
 */
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)];
	struct file_ra_state ra_state;
	int error, rgrps;

	mutex_lock(&sdp->sd_rindex_mutex);
	file_ra_state_init(&ra_state, inode->i_mapping);
	for (rgrps = 0;; rgrps++) {
		loff_t pos = rgrps * sizeof(struct gfs2_rindex);

515
		if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
516
517
518
519
520
			break;
		error = gfs2_internal_read(ip, &ra_state, buf, &pos,
					   sizeof(struct gfs2_rindex));
		if (error != sizeof(struct gfs2_rindex))
			break;
521
		total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
522
523
524
525
526
	}
	mutex_unlock(&sdp->sd_rindex_mutex);
	return total_data;
}

527
528
529
530
531
532
533
534
535
536
537
static void gfs2_rindex_in(struct gfs2_rgrpd *rgd, const void *buf)
{
	const struct gfs2_rindex *str = buf;

	rgd->rd_addr = be64_to_cpu(str->ri_addr);
	rgd->rd_length = be32_to_cpu(str->ri_length);
	rgd->rd_data0 = be64_to_cpu(str->ri_data0);
	rgd->rd_data = be32_to_cpu(str->ri_data);
	rgd->rd_bitbytes = be32_to_cpu(str->ri_bitbytes);
}

David Teigland's avatar
David Teigland committed
538
/**
539
 * read_rindex_entry - Pull in a new resource index entry from the disk
David Teigland's avatar
David Teigland committed
540
541
 * @gl: The glock covering the rindex inode
 *
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
 * Returns: 0 on success, error code otherwise
 */

static int read_rindex_entry(struct gfs2_inode *ip,
			     struct file_ra_state *ra_state)
{
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
	char buf[sizeof(struct gfs2_rindex)];
	int error;
	struct gfs2_rgrpd *rgd;

	error = gfs2_internal_read(ip, ra_state, buf, &pos,
				   sizeof(struct gfs2_rindex));
	if (!error)
		return 0;
	if (error != sizeof(struct gfs2_rindex)) {
		if (error > 0)
			error = -EIO;
		return error;
	}

564
	rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
565
566
567
568
569
570
571
572
573
574
575
	error = -ENOMEM;
	if (!rgd)
		return error;

	mutex_init(&rgd->rd_mutex);
	lops_init_le(&rgd->rd_le, &gfs2_rg_lops);
	rgd->rd_sbd = sdp;

	list_add_tail(&rgd->rd_list, &sdp->sd_rindex_list);
	list_add_tail(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);

576
	gfs2_rindex_in(rgd, buf);
577
578
579
580
	error = compute_bitstructs(rgd);
	if (error)
		return error;

581
	error = gfs2_glock_get(sdp, rgd->rd_addr,
582
583
584
585
586
			       &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
	if (error)
		return error;

	rgd->rd_gl->gl_object = rgd;
587
	rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
588
589
590
591
592
593
594
	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
595
596
597
 * Returns: 0 on successful update, error code otherwise
 */

598
int gfs2_ri_update(struct gfs2_inode *ip)
David Teigland's avatar
David Teigland committed
599
{
600
601
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
	struct inode *inode = &ip->i_inode;
602
	struct file_ra_state ra_state;
Steven Whitehouse's avatar
Steven Whitehouse committed
603
	u64 rgrp_count = i_size_read(inode);
Benjamin Marzinski's avatar
Benjamin Marzinski committed
604
605
	struct gfs2_rgrpd *rgd;
	unsigned int max_data = 0;
David Teigland's avatar
David Teigland committed
606
607
	int error;

Steven Whitehouse's avatar
Steven Whitehouse committed
608
	do_div(rgrp_count, sizeof(struct gfs2_rindex));
David Teigland's avatar
David Teigland committed
609
610
	clear_rgrpdi(sdp);

611
	file_ra_state_init(&ra_state, inode->i_mapping);
612
	for (sdp->sd_rgrps = 0; sdp->sd_rgrps < rgrp_count; sdp->sd_rgrps++) {
613
614
615
616
		error = read_rindex_entry(ip, &ra_state);
		if (error) {
			clear_rgrpdi(sdp);
			return error;
David Teigland's avatar
David Teigland committed
617
		}
618
	}
David Teigland's avatar
David Teigland committed
619

Benjamin Marzinski's avatar
Benjamin Marzinski committed
620
621
622
623
	list_for_each_entry(rgd, &sdp->sd_rindex_list, rd_list)
		if (rgd->rd_data > max_data)
			max_data = rgd->rd_data;
	sdp->sd_max_rg_data = max_data;
624
	sdp->sd_rindex_uptodate = 1;
625
626
	return 0;
}
David Teigland's avatar
David Teigland committed
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647

/**
 * gfs2_rindex_hold - Grab a lock on the rindex
 * @sdp: The GFS2 superblock
 * @ri_gh: the glock holder
 *
 * 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.
 *
 * Returns: 0 on success, error code otherwise
 */

int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh)
{
648
	struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
David Teigland's avatar
David Teigland committed
649
650
651
652
653
654
655
656
	struct gfs2_glock *gl = ip->i_gl;
	int error;

	error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, ri_gh);
	if (error)
		return error;

	/* Read new copy from disk if we don't have the latest */
657
	if (!sdp->sd_rindex_uptodate) {
658
		mutex_lock(&sdp->sd_rindex_mutex);
659
		if (!sdp->sd_rindex_uptodate) {
David Teigland's avatar
David Teigland committed
660
661
662
663
			error = gfs2_ri_update(ip);
			if (error)
				gfs2_glock_dq_uninit(ri_gh);
		}
664
		mutex_unlock(&sdp->sd_rindex_mutex);
David Teigland's avatar
David Teigland committed
665
666
667
668
669
	}

	return error;
}

670
static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
671
672
{
	const struct gfs2_rgrp *str = buf;
673
	u32 rg_flags;
674

675
	rg_flags = be32_to_cpu(str->rg_flags);
676
	rg_flags &= ~GFS2_RDF_MASK;
677
678
	rgd->rd_flags &= GFS2_RDF_MASK;
	rgd->rd_flags |= rg_flags;
679
	rgd->rd_free = be32_to_cpu(str->rg_free);
680
	rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
681
	rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
682
683
}

684
static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
685
686
687
{
	struct gfs2_rgrp *str = buf;

688
	str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
689
	str->rg_free = cpu_to_be32(rgd->rd_free);
690
	str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
691
	str->__pad = cpu_to_be32(0);
692
	str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
693
694
695
	memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
}

David Teigland's avatar
David Teigland committed
696
697
698
699
700
701
702
703
704
705
706
707
708
709
/**
 * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
 * @rgd: the struct gfs2_rgrpd describing the RG to read in
 *
 * 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
 */

int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	struct gfs2_glock *gl = rgd->rd_gl;
710
	unsigned int length = rgd->rd_length;
David Teigland's avatar
David Teigland committed
711
712
713
714
	struct gfs2_bitmap *bi;
	unsigned int x, y;
	int error;

715
	mutex_lock(&rgd->rd_mutex);
David Teigland's avatar
David Teigland committed
716
717
718
719
720

	spin_lock(&sdp->sd_rindex_spin);
	if (rgd->rd_bh_count) {
		rgd->rd_bh_count++;
		spin_unlock(&sdp->sd_rindex_spin);
721
		mutex_unlock(&rgd->rd_mutex);
David Teigland's avatar
David Teigland committed
722
723
724
725
726
727
		return 0;
	}
	spin_unlock(&sdp->sd_rindex_spin);

	for (x = 0; x < length; x++) {
		bi = rgd->rd_bits + x;
728
		error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
David Teigland's avatar
David Teigland committed
729
730
731
732
733
734
		if (error)
			goto fail;
	}

	for (y = length; y--;) {
		bi = rgd->rd_bits + y;
735
		error = gfs2_meta_wait(sdp, bi->bi_bh);
David Teigland's avatar
David Teigland committed
736
737
		if (error)
			goto fail;
738
		if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
David Teigland's avatar
David Teigland committed
739
740
741
742
743
744
					      GFS2_METATYPE_RG)) {
			error = -EIO;
			goto fail;
		}
	}

745
	if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
746
747
		for (x = 0; x < length; x++)
			clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
748
		gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
749
		rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
David Teigland's avatar
David Teigland committed
750
751
752
	}

	spin_lock(&sdp->sd_rindex_spin);
753
	rgd->rd_free_clone = rgd->rd_free;
David Teigland's avatar
David Teigland committed
754
755
756
	rgd->rd_bh_count++;
	spin_unlock(&sdp->sd_rindex_spin);

757
	mutex_unlock(&rgd->rd_mutex);
David Teigland's avatar
David Teigland committed
758
759
760

	return 0;

761
fail:
David Teigland's avatar
David Teigland committed
762
763
764
765
766
767
	while (x--) {
		bi = rgd->rd_bits + x;
		brelse(bi->bi_bh);
		bi->bi_bh = NULL;
		gfs2_assert_warn(sdp, !bi->bi_clone);
	}
768
	mutex_unlock(&rgd->rd_mutex);
David Teigland's avatar
David Teigland committed
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791

	return error;
}

void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd)
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;

	spin_lock(&sdp->sd_rindex_spin);
	gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count);
	rgd->rd_bh_count++;
	spin_unlock(&sdp->sd_rindex_spin);
}

/**
 * gfs2_rgrp_bh_put - Release RG bitmaps read in with gfs2_rgrp_bh_get()
 * @rgd: the struct gfs2_rgrpd describing the RG to read in
 *
 */

void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd)
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
792
	int x, length = rgd->rd_length;
David Teigland's avatar
David Teigland committed
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811

	spin_lock(&sdp->sd_rindex_spin);
	gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count);
	if (--rgd->rd_bh_count) {
		spin_unlock(&sdp->sd_rindex_spin);
		return;
	}

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

	spin_unlock(&sdp->sd_rindex_spin);
}

812
813
814
815
816
817
static void gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
				    const struct gfs2_bitmap *bi)
{
	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 /
818
					   bdev_logical_block_size(sb->s_bdev);
819
	u64 blk;
820
	sector_t start = 0;
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
	sector_t nr_sects = 0;
	int rv;
	unsigned int x;

	for (x = 0; x < bi->bi_len; x++) {
		const u8 *orig = bi->bi_bh->b_data + bi->bi_offset + x;
		const u8 *clone = bi->bi_clone + bi->bi_offset + x;
		u8 diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));
		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) {
					rv = blkdev_issue_discard(bdev, start,
840
							    nr_sects, GFP_NOFS,
841
							    0);
842
843
844
845
846
847
848
849
850
851
852
853
854
					if (rv)
						goto fail;
					nr_sects = 0;
start_new_extent:
					start = blk;
				}
				nr_sects += sects_per_blk;
			}
			diff >>= 2;
			blk += sects_per_blk;
		}
	}
	if (nr_sects) {
855
		rv = blkdev_issue_discard(bdev, start, nr_sects, GFP_NOFS, 0);
856
857
858
859
860
861
862
863
864
		if (rv)
			goto fail;
	}
	return;
fail:
	fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem", rv);
	sdp->sd_args.ar_discard = 0;
}

David Teigland's avatar
David Teigland committed
865
866
867
void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd)
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
868
	unsigned int length = rgd->rd_length;
David Teigland's avatar
David Teigland committed
869
870
871
872
873
874
	unsigned int x;

	for (x = 0; x < length; x++) {
		struct gfs2_bitmap *bi = rgd->rd_bits + x;
		if (!bi->bi_clone)
			continue;
875
876
		if (sdp->sd_args.ar_discard)
			gfs2_rgrp_send_discards(sdp, rgd->rd_data0, bi);
877
		clear_bit(GBF_FULL, &bi->bi_flags);
David Teigland's avatar
David Teigland committed
878
		memcpy(bi->bi_clone + bi->bi_offset,
879
		       bi->bi_bh->b_data + bi->bi_offset, bi->bi_len);
David Teigland's avatar
David Teigland committed
880
881
882
	}

	spin_lock(&sdp->sd_rindex_spin);
883
	rgd->rd_free_clone = rgd->rd_free;
David Teigland's avatar
David Teigland committed
884
885
886
887
888
889
890
891
892
893
894
895
	spin_unlock(&sdp->sd_rindex_spin);
}

/**
 * gfs2_alloc_get - get the struct gfs2_alloc structure for an inode
 * @ip: the incore GFS2 inode structure
 *
 * Returns: the struct gfs2_alloc
 */

struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip)
{
896
	BUG_ON(ip->i_alloc != NULL);
897
	ip->i_alloc = kzalloc(sizeof(struct gfs2_alloc), GFP_NOFS);
898
	return ip->i_alloc;
David Teigland's avatar
David Teigland committed
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
}

/**
 * try_rgrp_fit - See if a given reservation will fit in a given RG
 * @rgd: the RG data
 * @al: the struct gfs2_alloc structure describing the reservation
 *
 * If there's room for the requested blocks to be allocated from the RG:
 *   Sets the $al_rgd field in @al.
 *
 * Returns: 1 on success (it fits), 0 on failure (it doesn't fit)
 */

static int try_rgrp_fit(struct gfs2_rgrpd *rgd, struct gfs2_alloc *al)
{
	struct gfs2_sbd *sdp = rgd->rd_sbd;
	int ret = 0;

917
	if (rgd->rd_flags & (GFS2_RGF_NOALLOC | GFS2_RDF_ERROR))
918
919
		return 0;

David Teigland's avatar
David Teigland committed
920
921
922
923
924
925
926
927
928
929
	spin_lock(&sdp->sd_rindex_spin);
	if (rgd->rd_free_clone >= al->al_requested) {
		al->al_rgd = rgd;
		ret = 1;
	}
	spin_unlock(&sdp->sd_rindex_spin);

	return ret;
}

930
931
932
933
/**
 * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
 * @rgd: The rgrp
 *
Bob Peterson's avatar
Bob Peterson committed
934
935
 * Returns: 0 if no error
 *          The inode, if one has been found, in inode.
936
937
 */

938
static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
939
{
940
	u32 goal = 0, block;
941
	u64 no_addr;
942
	struct gfs2_sbd *sdp = rgd->rd_sbd;
943
	unsigned int n;
944
945
946
947
	struct gfs2_glock *gl;
	struct gfs2_inode *ip;
	int error;
	int found = 0;
948

949
	while (goal < rgd->rd_data) {
950
		down_write(&sdp->sd_log_flush_lock);
951
		n = 1;
952
		block = rgblk_search(rgd, goal, GFS2_BLKST_UNLINKED,
953
				     GFS2_BLKST_UNLINKED, &n);
954
		up_write(&sdp->sd_log_flush_lock);
955
		if (block == BFITNOENT)
956
			break;
957
958
959
		/* rgblk_search can return a block < goal, so we need to
		   keep it marching forward. */
		no_addr = block + rgd->rd_data0;
960
		goal = max(block + 1, goal + 1);
961
		if (*last_unlinked != NO_BLOCK && no_addr <= *last_unlinked)
962
			continue;
963
964
		if (no_addr == skip)
			continue;
965
		*last_unlinked = no_addr;
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985

		error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &gl);
		if (error)
			continue;

		/* If the inode is already in cache, we can ignore it here
		 * because the existing inode disposal code will deal with
		 * it when all refs have gone away. Accessing gl_object like
		 * this is not safe in general. Here it is ok because we do
		 * not dereference the pointer, and we only need an approx
		 * answer to whether it is NULL or not.
		 */
		ip = gl->gl_object;

		if (ip || queue_work(gfs2_delete_workqueue, &gl->gl_delete) == 0)
			gfs2_glock_put(gl);
		else
			found++;

		/* Limit reclaim to sensible number of tasks */
986
		if (found > NR_CPUS)
987
			return;
988
989
990
	}

	rgd->rd_flags &= ~GFS2_RDF_CHECK;
991
	return;
992
993
}

David Teigland's avatar
David Teigland committed
994
995
996
997
998
999
1000
/**
 * recent_rgrp_next - get next RG from "recent" list
 * @cur_rgd: current rgrp
 *
 * Returns: The next rgrp in the recent list
 */

For faster browsing, not all history is shown. View entire blame