Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-nmw
[~shefty/rdma-dev.git] / fs / gfs2 / rgrp.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
9
10 #include <linux/slab.h>
11 #include <linux/spinlock.h>
12 #include <linux/completion.h>
13 #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>
19 #include <linux/random.h>
20
21 #include "gfs2.h"
22 #include "incore.h"
23 #include "glock.h"
24 #include "glops.h"
25 #include "lops.h"
26 #include "meta_io.h"
27 #include "quota.h"
28 #include "rgrp.h"
29 #include "super.h"
30 #include "trans.h"
31 #include "util.h"
32 #include "log.h"
33 #include "inode.h"
34 #include "trace_gfs2.h"
35
36 #define BFITNOENT ((u32)~0)
37 #define NO_BLOCK ((u64)~0)
38
39 #if BITS_PER_LONG == 32
40 #define LBITMASK   (0x55555555UL)
41 #define LBITSKIP55 (0x55555555UL)
42 #define LBITSKIP00 (0x00000000UL)
43 #else
44 #define LBITMASK   (0x5555555555555555UL)
45 #define LBITSKIP55 (0x5555555555555555UL)
46 #define LBITSKIP00 (0x0000000000000000UL)
47 #endif
48
49 /*
50  * These routines are used by the resource group routines (rgrp.c)
51  * to keep track of block allocation.  Each block is represented by two
52  * bits.  So, each byte represents GFS2_NBBY (i.e. 4) blocks.
53  *
54  * 0 = Free
55  * 1 = Used (not metadata)
56  * 2 = Unlinked (still in use) inode
57  * 3 = Used (metadata)
58  */
59
60 static const char valid_change[16] = {
61                 /* current */
62         /* n */ 0, 1, 1, 1,
63         /* e */ 1, 0, 0, 0,
64         /* w */ 0, 0, 0, 1,
65                 1, 0, 0, 0
66 };
67
68 static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 minext,
69                          const struct gfs2_inode *ip, bool nowrap);
70
71
72 /**
73  * gfs2_setbit - Set a bit in the bitmaps
74  * @rbm: The position of the bit to set
75  * @do_clone: Also set the clone bitmap, if it exists
76  * @new_state: the new state of the block
77  *
78  */
79
80 static inline void gfs2_setbit(const struct gfs2_rbm *rbm, bool do_clone,
81                                unsigned char new_state)
82 {
83         unsigned char *byte1, *byte2, *end, cur_state;
84         unsigned int buflen = rbm->bi->bi_len;
85         const unsigned int bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
86
87         byte1 = rbm->bi->bi_bh->b_data + rbm->bi->bi_offset + (rbm->offset / GFS2_NBBY);
88         end = rbm->bi->bi_bh->b_data + rbm->bi->bi_offset + buflen;
89
90         BUG_ON(byte1 >= end);
91
92         cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
93
94         if (unlikely(!valid_change[new_state * 4 + cur_state])) {
95                 printk(KERN_WARNING "GFS2: buf_blk = 0x%x old_state=%d, "
96                        "new_state=%d\n", rbm->offset, cur_state, new_state);
97                 printk(KERN_WARNING "GFS2: rgrp=0x%llx bi_start=0x%x\n",
98                        (unsigned long long)rbm->rgd->rd_addr,
99                        rbm->bi->bi_start);
100                 printk(KERN_WARNING "GFS2: bi_offset=0x%x bi_len=0x%x\n",
101                        rbm->bi->bi_offset, rbm->bi->bi_len);
102                 dump_stack();
103                 gfs2_consist_rgrpd(rbm->rgd);
104                 return;
105         }
106         *byte1 ^= (cur_state ^ new_state) << bit;
107
108         if (do_clone && rbm->bi->bi_clone) {
109                 byte2 = rbm->bi->bi_clone + rbm->bi->bi_offset + (rbm->offset / GFS2_NBBY);
110                 cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
111                 *byte2 ^= (cur_state ^ new_state) << bit;
112         }
113 }
114
115 /**
116  * gfs2_testbit - test a bit in the bitmaps
117  * @rbm: The bit to test
118  *
119  * Returns: The two bit block state of the requested bit
120  */
121
122 static inline u8 gfs2_testbit(const struct gfs2_rbm *rbm)
123 {
124         const u8 *buffer = rbm->bi->bi_bh->b_data + rbm->bi->bi_offset;
125         const u8 *byte;
126         unsigned int bit;
127
128         byte = buffer + (rbm->offset / GFS2_NBBY);
129         bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
130
131         return (*byte >> bit) & GFS2_BIT_MASK;
132 }
133
134 /**
135  * gfs2_bit_search
136  * @ptr: Pointer to bitmap data
137  * @mask: Mask to use (normally 0x55555.... but adjusted for search start)
138  * @state: The state we are searching for
139  *
140  * We xor the bitmap data with a patter which is the bitwise opposite
141  * of what we are looking for, this gives rise to a pattern of ones
142  * wherever there is a match. Since we have two bits per entry, we
143  * take this pattern, shift it down by one place and then and it with
144  * the original. All the even bit positions (0,2,4, etc) then represent
145  * successful matches, so we mask with 0x55555..... to remove the unwanted
146  * odd bit positions.
147  *
148  * This allows searching of a whole u64 at once (32 blocks) with a
149  * single test (on 64 bit arches).
150  */
151
152 static inline u64 gfs2_bit_search(const __le64 *ptr, u64 mask, u8 state)
153 {
154         u64 tmp;
155         static const u64 search[] = {
156                 [0] = 0xffffffffffffffffULL,
157                 [1] = 0xaaaaaaaaaaaaaaaaULL,
158                 [2] = 0x5555555555555555ULL,
159                 [3] = 0x0000000000000000ULL,
160         };
161         tmp = le64_to_cpu(*ptr) ^ search[state];
162         tmp &= (tmp >> 1);
163         tmp &= mask;
164         return tmp;
165 }
166
167 /**
168  * rs_cmp - multi-block reservation range compare
169  * @blk: absolute file system block number of the new reservation
170  * @len: number of blocks in the new reservation
171  * @rs: existing reservation to compare against
172  *
173  * returns: 1 if the block range is beyond the reach of the reservation
174  *         -1 if the block range is before the start of the reservation
175  *          0 if the block range overlaps with the reservation
176  */
177 static inline int rs_cmp(u64 blk, u32 len, struct gfs2_blkreserv *rs)
178 {
179         u64 startblk = gfs2_rbm_to_block(&rs->rs_rbm);
180
181         if (blk >= startblk + rs->rs_free)
182                 return 1;
183         if (blk + len - 1 < startblk)
184                 return -1;
185         return 0;
186 }
187
188 /**
189  * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
190  *       a block in a given allocation state.
191  * @buf: the buffer that holds the bitmaps
192  * @len: the length (in bytes) of the buffer
193  * @goal: start search at this block's bit-pair (within @buffer)
194  * @state: GFS2_BLKST_XXX the state of the block we're looking for.
195  *
196  * Scope of @goal and returned block number is only within this bitmap buffer,
197  * not entire rgrp or filesystem.  @buffer will be offset from the actual
198  * beginning of a bitmap block buffer, skipping any header structures, but
199  * headers are always a multiple of 64 bits long so that the buffer is
200  * always aligned to a 64 bit boundary.
201  *
202  * The size of the buffer is in bytes, but is it assumed that it is
203  * always ok to read a complete multiple of 64 bits at the end
204  * of the block in case the end is no aligned to a natural boundary.
205  *
206  * Return: the block number (bitmap buffer scope) that was found
207  */
208
209 static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
210                        u32 goal, u8 state)
211 {
212         u32 spoint = (goal << 1) & ((8*sizeof(u64)) - 1);
213         const __le64 *ptr = ((__le64 *)buf) + (goal >> 5);
214         const __le64 *end = (__le64 *)(buf + ALIGN(len, sizeof(u64)));
215         u64 tmp;
216         u64 mask = 0x5555555555555555ULL;
217         u32 bit;
218
219         /* Mask off bits we don't care about at the start of the search */
220         mask <<= spoint;
221         tmp = gfs2_bit_search(ptr, mask, state);
222         ptr++;
223         while(tmp == 0 && ptr < end) {
224                 tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
225                 ptr++;
226         }
227         /* Mask off any bits which are more than len bytes from the start */
228         if (ptr == end && (len & (sizeof(u64) - 1)))
229                 tmp &= (((u64)~0) >> (64 - 8*(len & (sizeof(u64) - 1))));
230         /* Didn't find anything, so return */
231         if (tmp == 0)
232                 return BFITNOENT;
233         ptr--;
234         bit = __ffs64(tmp);
235         bit /= 2;       /* two bits per entry in the bitmap */
236         return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
237 }
238
239 /**
240  * gfs2_rbm_from_block - Set the rbm based upon rgd and block number
241  * @rbm: The rbm with rgd already set correctly
242  * @block: The block number (filesystem relative)
243  *
244  * This sets the bi and offset members of an rbm based on a
245  * resource group and a filesystem relative block number. The
246  * resource group must be set in the rbm on entry, the bi and
247  * offset members will be set by this function.
248  *
249  * Returns: 0 on success, or an error code
250  */
251
252 static int gfs2_rbm_from_block(struct gfs2_rbm *rbm, u64 block)
253 {
254         u64 rblock = block - rbm->rgd->rd_data0;
255         u32 x;
256
257         if (WARN_ON_ONCE(rblock > UINT_MAX))
258                 return -EINVAL;
259         if (block >= rbm->rgd->rd_data0 + rbm->rgd->rd_data)
260                 return -E2BIG;
261
262         rbm->bi = rbm->rgd->rd_bits;
263         rbm->offset = (u32)(rblock);
264         /* Check if the block is within the first block */
265         if (rbm->offset < (rbm->bi->bi_start + rbm->bi->bi_len) * GFS2_NBBY)
266                 return 0;
267
268         /* Adjust for the size diff between gfs2_meta_header and gfs2_rgrp */
269         rbm->offset += (sizeof(struct gfs2_rgrp) -
270                         sizeof(struct gfs2_meta_header)) * GFS2_NBBY;
271         x = rbm->offset / rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
272         rbm->offset -= x * rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
273         rbm->bi += x;
274         return 0;
275 }
276
277 /**
278  * gfs2_unaligned_extlen - Look for free blocks which are not byte aligned
279  * @rbm: Position to search (value/result)
280  * @n_unaligned: Number of unaligned blocks to check
281  * @len: Decremented for each block found (terminate on zero)
282  *
283  * Returns: true if a non-free block is encountered
284  */
285
286 static bool gfs2_unaligned_extlen(struct gfs2_rbm *rbm, u32 n_unaligned, u32 *len)
287 {
288         u64 block;
289         u32 n;
290         u8 res;
291
292         for (n = 0; n < n_unaligned; n++) {
293                 res = gfs2_testbit(rbm);
294                 if (res != GFS2_BLKST_FREE)
295                         return true;
296                 (*len)--;
297                 if (*len == 0)
298                         return true;
299                 block = gfs2_rbm_to_block(rbm);
300                 if (gfs2_rbm_from_block(rbm, block + 1))
301                         return true;
302         }
303
304         return false;
305 }
306
307 /**
308  * gfs2_free_extlen - Return extent length of free blocks
309  * @rbm: Starting position
310  * @len: Max length to check
311  *
312  * Starting at the block specified by the rbm, see how many free blocks
313  * there are, not reading more than len blocks ahead. This can be done
314  * using memchr_inv when the blocks are byte aligned, but has to be done
315  * on a block by block basis in case of unaligned blocks. Also this
316  * function can cope with bitmap boundaries (although it must stop on
317  * a resource group boundary)
318  *
319  * Returns: Number of free blocks in the extent
320  */
321
322 static u32 gfs2_free_extlen(const struct gfs2_rbm *rrbm, u32 len)
323 {
324         struct gfs2_rbm rbm = *rrbm;
325         u32 n_unaligned = rbm.offset & 3;
326         u32 size = len;
327         u32 bytes;
328         u32 chunk_size;
329         u8 *ptr, *start, *end;
330         u64 block;
331
332         if (n_unaligned &&
333             gfs2_unaligned_extlen(&rbm, 4 - n_unaligned, &len))
334                 goto out;
335
336         n_unaligned = len & 3;
337         /* Start is now byte aligned */
338         while (len > 3) {
339                 start = rbm.bi->bi_bh->b_data;
340                 if (rbm.bi->bi_clone)
341                         start = rbm.bi->bi_clone;
342                 end = start + rbm.bi->bi_bh->b_size;
343                 start += rbm.bi->bi_offset;
344                 BUG_ON(rbm.offset & 3);
345                 start += (rbm.offset / GFS2_NBBY);
346                 bytes = min_t(u32, len / GFS2_NBBY, (end - start));
347                 ptr = memchr_inv(start, 0, bytes);
348                 chunk_size = ((ptr == NULL) ? bytes : (ptr - start));
349                 chunk_size *= GFS2_NBBY;
350                 BUG_ON(len < chunk_size);
351                 len -= chunk_size;
352                 block = gfs2_rbm_to_block(&rbm);
353                 if (gfs2_rbm_from_block(&rbm, block + chunk_size)) {
354                         n_unaligned = 0;
355                         break;
356                 }
357                 if (ptr) {
358                         n_unaligned = 3;
359                         break;
360                 }
361                 n_unaligned = len & 3;
362         }
363
364         /* Deal with any bits left over at the end */
365         if (n_unaligned)
366                 gfs2_unaligned_extlen(&rbm, n_unaligned, &len);
367 out:
368         return size - len;
369 }
370
371 /**
372  * gfs2_bitcount - count the number of bits in a certain state
373  * @rgd: the resource group descriptor
374  * @buffer: the buffer that holds the bitmaps
375  * @buflen: the length (in bytes) of the buffer
376  * @state: the state of the block we're looking for
377  *
378  * Returns: The number of bits
379  */
380
381 static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
382                          unsigned int buflen, u8 state)
383 {
384         const u8 *byte = buffer;
385         const u8 *end = buffer + buflen;
386         const u8 state1 = state << 2;
387         const u8 state2 = state << 4;
388         const u8 state3 = state << 6;
389         u32 count = 0;
390
391         for (; byte < end; byte++) {
392                 if (((*byte) & 0x03) == state)
393                         count++;
394                 if (((*byte) & 0x0C) == state1)
395                         count++;
396                 if (((*byte) & 0x30) == state2)
397                         count++;
398                 if (((*byte) & 0xC0) == state3)
399                         count++;
400         }
401
402         return count;
403 }
404
405 /**
406  * gfs2_rgrp_verify - Verify that a resource group is consistent
407  * @rgd: the rgrp
408  *
409  */
410
411 void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
412 {
413         struct gfs2_sbd *sdp = rgd->rd_sbd;
414         struct gfs2_bitmap *bi = NULL;
415         u32 length = rgd->rd_length;
416         u32 count[4], tmp;
417         int buf, x;
418
419         memset(count, 0, 4 * sizeof(u32));
420
421         /* Count # blocks in each of 4 possible allocation states */
422         for (buf = 0; buf < length; buf++) {
423                 bi = rgd->rd_bits + buf;
424                 for (x = 0; x < 4; x++)
425                         count[x] += gfs2_bitcount(rgd,
426                                                   bi->bi_bh->b_data +
427                                                   bi->bi_offset,
428                                                   bi->bi_len, x);
429         }
430
431         if (count[0] != rgd->rd_free) {
432                 if (gfs2_consist_rgrpd(rgd))
433                         fs_err(sdp, "free data mismatch:  %u != %u\n",
434                                count[0], rgd->rd_free);
435                 return;
436         }
437
438         tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
439         if (count[1] != tmp) {
440                 if (gfs2_consist_rgrpd(rgd))
441                         fs_err(sdp, "used data mismatch:  %u != %u\n",
442                                count[1], tmp);
443                 return;
444         }
445
446         if (count[2] + count[3] != rgd->rd_dinodes) {
447                 if (gfs2_consist_rgrpd(rgd))
448                         fs_err(sdp, "used metadata mismatch:  %u != %u\n",
449                                count[2] + count[3], rgd->rd_dinodes);
450                 return;
451         }
452 }
453
454 static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block)
455 {
456         u64 first = rgd->rd_data0;
457         u64 last = first + rgd->rd_data;
458         return first <= block && block < last;
459 }
460
461 /**
462  * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
463  * @sdp: The GFS2 superblock
464  * @blk: The data block number
465  * @exact: True if this needs to be an exact match
466  *
467  * Returns: The resource group, or NULL if not found
468  */
469
470 struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
471 {
472         struct rb_node *n, *next;
473         struct gfs2_rgrpd *cur;
474
475         spin_lock(&sdp->sd_rindex_spin);
476         n = sdp->sd_rindex_tree.rb_node;
477         while (n) {
478                 cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
479                 next = NULL;
480                 if (blk < cur->rd_addr)
481                         next = n->rb_left;
482                 else if (blk >= cur->rd_data0 + cur->rd_data)
483                         next = n->rb_right;
484                 if (next == NULL) {
485                         spin_unlock(&sdp->sd_rindex_spin);
486                         if (exact) {
487                                 if (blk < cur->rd_addr)
488                                         return NULL;
489                                 if (blk >= cur->rd_data0 + cur->rd_data)
490                                         return NULL;
491                         }
492                         return cur;
493                 }
494                 n = next;
495         }
496         spin_unlock(&sdp->sd_rindex_spin);
497
498         return NULL;
499 }
500
501 /**
502  * gfs2_rgrpd_get_first - get the first Resource Group in the filesystem
503  * @sdp: The GFS2 superblock
504  *
505  * Returns: The first rgrp in the filesystem
506  */
507
508 struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp)
509 {
510         const struct rb_node *n;
511         struct gfs2_rgrpd *rgd;
512
513         spin_lock(&sdp->sd_rindex_spin);
514         n = rb_first(&sdp->sd_rindex_tree);
515         rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
516         spin_unlock(&sdp->sd_rindex_spin);
517
518         return rgd;
519 }
520
521 /**
522  * gfs2_rgrpd_get_next - get the next RG
523  * @rgd: the resource group descriptor
524  *
525  * Returns: The next rgrp
526  */
527
528 struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
529 {
530         struct gfs2_sbd *sdp = rgd->rd_sbd;
531         const struct rb_node *n;
532
533         spin_lock(&sdp->sd_rindex_spin);
534         n = rb_next(&rgd->rd_node);
535         if (n == NULL)
536                 n = rb_first(&sdp->sd_rindex_tree);
537
538         if (unlikely(&rgd->rd_node == n)) {
539                 spin_unlock(&sdp->sd_rindex_spin);
540                 return NULL;
541         }
542         rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
543         spin_unlock(&sdp->sd_rindex_spin);
544         return rgd;
545 }
546
547 void gfs2_free_clones(struct gfs2_rgrpd *rgd)
548 {
549         int x;
550
551         for (x = 0; x < rgd->rd_length; x++) {
552                 struct gfs2_bitmap *bi = rgd->rd_bits + x;
553                 kfree(bi->bi_clone);
554                 bi->bi_clone = NULL;
555         }
556 }
557
558 /**
559  * gfs2_rs_alloc - make sure we have a reservation assigned to the inode
560  * @ip: the inode for this reservation
561  */
562 int gfs2_rs_alloc(struct gfs2_inode *ip)
563 {
564         int error = 0;
565
566         down_write(&ip->i_rw_mutex);
567         if (ip->i_res)
568                 goto out;
569
570         ip->i_res = kmem_cache_zalloc(gfs2_rsrv_cachep, GFP_NOFS);
571         if (!ip->i_res) {
572                 error = -ENOMEM;
573                 goto out;
574         }
575
576         RB_CLEAR_NODE(&ip->i_res->rs_node);
577 out:
578         up_write(&ip->i_rw_mutex);
579         return 0;
580 }
581
582 static void dump_rs(struct seq_file *seq, const struct gfs2_blkreserv *rs)
583 {
584         gfs2_print_dbg(seq, "  B: n:%llu s:%llu b:%u f:%u\n",
585                        (unsigned long long)rs->rs_inum,
586                        (unsigned long long)gfs2_rbm_to_block(&rs->rs_rbm),
587                        rs->rs_rbm.offset, rs->rs_free);
588 }
589
590 /**
591  * __rs_deltree - remove a multi-block reservation from the rgd tree
592  * @rs: The reservation to remove
593  *
594  */
595 static void __rs_deltree(struct gfs2_inode *ip, struct gfs2_blkreserv *rs)
596 {
597         struct gfs2_rgrpd *rgd;
598
599         if (!gfs2_rs_active(rs))
600                 return;
601
602         rgd = rs->rs_rbm.rgd;
603         trace_gfs2_rs(rs, TRACE_RS_TREEDEL);
604         rb_erase(&rs->rs_node, &rgd->rd_rstree);
605         RB_CLEAR_NODE(&rs->rs_node);
606
607         if (rs->rs_free) {
608                 /* return reserved blocks to the rgrp and the ip */
609                 BUG_ON(rs->rs_rbm.rgd->rd_reserved < rs->rs_free);
610                 rs->rs_rbm.rgd->rd_reserved -= rs->rs_free;
611                 rs->rs_free = 0;
612                 clear_bit(GBF_FULL, &rs->rs_rbm.bi->bi_flags);
613                 smp_mb__after_clear_bit();
614         }
615 }
616
617 /**
618  * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
619  * @rs: The reservation to remove
620  *
621  */
622 void gfs2_rs_deltree(struct gfs2_inode *ip, struct gfs2_blkreserv *rs)
623 {
624         struct gfs2_rgrpd *rgd;
625
626         rgd = rs->rs_rbm.rgd;
627         if (rgd) {
628                 spin_lock(&rgd->rd_rsspin);
629                 __rs_deltree(ip, rs);
630                 spin_unlock(&rgd->rd_rsspin);
631         }
632 }
633
634 /**
635  * gfs2_rs_delete - delete a multi-block reservation
636  * @ip: The inode for this reservation
637  *
638  */
639 void gfs2_rs_delete(struct gfs2_inode *ip)
640 {
641         down_write(&ip->i_rw_mutex);
642         if (ip->i_res) {
643                 gfs2_rs_deltree(ip, ip->i_res);
644                 BUG_ON(ip->i_res->rs_free);
645                 kmem_cache_free(gfs2_rsrv_cachep, ip->i_res);
646                 ip->i_res = NULL;
647         }
648         up_write(&ip->i_rw_mutex);
649 }
650
651 /**
652  * return_all_reservations - return all reserved blocks back to the rgrp.
653  * @rgd: the rgrp that needs its space back
654  *
655  * We previously reserved a bunch of blocks for allocation. Now we need to
656  * give them back. This leave the reservation structures in tact, but removes
657  * all of their corresponding "no-fly zones".
658  */
659 static void return_all_reservations(struct gfs2_rgrpd *rgd)
660 {
661         struct rb_node *n;
662         struct gfs2_blkreserv *rs;
663
664         spin_lock(&rgd->rd_rsspin);
665         while ((n = rb_first(&rgd->rd_rstree))) {
666                 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
667                 __rs_deltree(NULL, rs);
668         }
669         spin_unlock(&rgd->rd_rsspin);
670 }
671
672 void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
673 {
674         struct rb_node *n;
675         struct gfs2_rgrpd *rgd;
676         struct gfs2_glock *gl;
677
678         while ((n = rb_first(&sdp->sd_rindex_tree))) {
679                 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
680                 gl = rgd->rd_gl;
681
682                 rb_erase(n, &sdp->sd_rindex_tree);
683
684                 if (gl) {
685                         spin_lock(&gl->gl_spin);
686                         gl->gl_object = NULL;
687                         spin_unlock(&gl->gl_spin);
688                         gfs2_glock_add_to_lru(gl);
689                         gfs2_glock_put(gl);
690                 }
691
692                 gfs2_free_clones(rgd);
693                 kfree(rgd->rd_bits);
694                 return_all_reservations(rgd);
695                 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
696         }
697 }
698
699 static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd)
700 {
701         printk(KERN_INFO "  ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
702         printk(KERN_INFO "  ri_length = %u\n", rgd->rd_length);
703         printk(KERN_INFO "  ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
704         printk(KERN_INFO "  ri_data = %u\n", rgd->rd_data);
705         printk(KERN_INFO "  ri_bitbytes = %u\n", rgd->rd_bitbytes);
706 }
707
708 /**
709  * gfs2_compute_bitstructs - Compute the bitmap sizes
710  * @rgd: The resource group descriptor
711  *
712  * Calculates bitmap descriptors, one for each block that contains bitmap data
713  *
714  * Returns: errno
715  */
716
717 static int compute_bitstructs(struct gfs2_rgrpd *rgd)
718 {
719         struct gfs2_sbd *sdp = rgd->rd_sbd;
720         struct gfs2_bitmap *bi;
721         u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
722         u32 bytes_left, bytes;
723         int x;
724
725         if (!length)
726                 return -EINVAL;
727
728         rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
729         if (!rgd->rd_bits)
730                 return -ENOMEM;
731
732         bytes_left = rgd->rd_bitbytes;
733
734         for (x = 0; x < length; x++) {
735                 bi = rgd->rd_bits + x;
736
737                 bi->bi_flags = 0;
738                 /* small rgrp; bitmap stored completely in header block */
739                 if (length == 1) {
740                         bytes = bytes_left;
741                         bi->bi_offset = sizeof(struct gfs2_rgrp);
742                         bi->bi_start = 0;
743                         bi->bi_len = bytes;
744                 /* header block */
745                 } else if (x == 0) {
746                         bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
747                         bi->bi_offset = sizeof(struct gfs2_rgrp);
748                         bi->bi_start = 0;
749                         bi->bi_len = bytes;
750                 /* last block */
751                 } else if (x + 1 == length) {
752                         bytes = bytes_left;
753                         bi->bi_offset = sizeof(struct gfs2_meta_header);
754                         bi->bi_start = rgd->rd_bitbytes - bytes_left;
755                         bi->bi_len = bytes;
756                 /* other blocks */
757                 } else {
758                         bytes = sdp->sd_sb.sb_bsize -
759                                 sizeof(struct gfs2_meta_header);
760                         bi->bi_offset = sizeof(struct gfs2_meta_header);
761                         bi->bi_start = rgd->rd_bitbytes - bytes_left;
762                         bi->bi_len = bytes;
763                 }
764
765                 bytes_left -= bytes;
766         }
767
768         if (bytes_left) {
769                 gfs2_consist_rgrpd(rgd);
770                 return -EIO;
771         }
772         bi = rgd->rd_bits + (length - 1);
773         if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
774                 if (gfs2_consist_rgrpd(rgd)) {
775                         gfs2_rindex_print(rgd);
776                         fs_err(sdp, "start=%u len=%u offset=%u\n",
777                                bi->bi_start, bi->bi_len, bi->bi_offset);
778                 }
779                 return -EIO;
780         }
781
782         return 0;
783 }
784
785 /**
786  * gfs2_ri_total - Total up the file system space, according to the rindex.
787  * @sdp: the filesystem
788  *
789  */
790 u64 gfs2_ri_total(struct gfs2_sbd *sdp)
791 {
792         u64 total_data = 0;     
793         struct inode *inode = sdp->sd_rindex;
794         struct gfs2_inode *ip = GFS2_I(inode);
795         char buf[sizeof(struct gfs2_rindex)];
796         int error, rgrps;
797
798         for (rgrps = 0;; rgrps++) {
799                 loff_t pos = rgrps * sizeof(struct gfs2_rindex);
800
801                 if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
802                         break;
803                 error = gfs2_internal_read(ip, buf, &pos,
804                                            sizeof(struct gfs2_rindex));
805                 if (error != sizeof(struct gfs2_rindex))
806                         break;
807                 total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
808         }
809         return total_data;
810 }
811
812 static int rgd_insert(struct gfs2_rgrpd *rgd)
813 {
814         struct gfs2_sbd *sdp = rgd->rd_sbd;
815         struct rb_node **newn = &sdp->sd_rindex_tree.rb_node, *parent = NULL;
816
817         /* Figure out where to put new node */
818         while (*newn) {
819                 struct gfs2_rgrpd *cur = rb_entry(*newn, struct gfs2_rgrpd,
820                                                   rd_node);
821
822                 parent = *newn;
823                 if (rgd->rd_addr < cur->rd_addr)
824                         newn = &((*newn)->rb_left);
825                 else if (rgd->rd_addr > cur->rd_addr)
826                         newn = &((*newn)->rb_right);
827                 else
828                         return -EEXIST;
829         }
830
831         rb_link_node(&rgd->rd_node, parent, newn);
832         rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
833         sdp->sd_rgrps++;
834         return 0;
835 }
836
837 /**
838  * read_rindex_entry - Pull in a new resource index entry from the disk
839  * @ip: Pointer to the rindex inode
840  *
841  * Returns: 0 on success, > 0 on EOF, error code otherwise
842  */
843
844 static int read_rindex_entry(struct gfs2_inode *ip)
845 {
846         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
847         loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
848         struct gfs2_rindex buf;
849         int error;
850         struct gfs2_rgrpd *rgd;
851
852         if (pos >= i_size_read(&ip->i_inode))
853                 return 1;
854
855         error = gfs2_internal_read(ip, (char *)&buf, &pos,
856                                    sizeof(struct gfs2_rindex));
857
858         if (error != sizeof(struct gfs2_rindex))
859                 return (error == 0) ? 1 : error;
860
861         rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
862         error = -ENOMEM;
863         if (!rgd)
864                 return error;
865
866         rgd->rd_sbd = sdp;
867         rgd->rd_addr = be64_to_cpu(buf.ri_addr);
868         rgd->rd_length = be32_to_cpu(buf.ri_length);
869         rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
870         rgd->rd_data = be32_to_cpu(buf.ri_data);
871         rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
872         spin_lock_init(&rgd->rd_rsspin);
873
874         error = compute_bitstructs(rgd);
875         if (error)
876                 goto fail;
877
878         error = gfs2_glock_get(sdp, rgd->rd_addr,
879                                &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
880         if (error)
881                 goto fail;
882
883         rgd->rd_gl->gl_object = rgd;
884         rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lksb.sb_lvbptr;
885         rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
886         if (rgd->rd_data > sdp->sd_max_rg_data)
887                 sdp->sd_max_rg_data = rgd->rd_data;
888         spin_lock(&sdp->sd_rindex_spin);
889         error = rgd_insert(rgd);
890         spin_unlock(&sdp->sd_rindex_spin);
891         if (!error)
892                 return 0;
893
894         error = 0; /* someone else read in the rgrp; free it and ignore it */
895         gfs2_glock_put(rgd->rd_gl);
896
897 fail:
898         kfree(rgd->rd_bits);
899         kmem_cache_free(gfs2_rgrpd_cachep, rgd);
900         return error;
901 }
902
903 /**
904  * gfs2_ri_update - Pull in a new resource index from the disk
905  * @ip: pointer to the rindex inode
906  *
907  * Returns: 0 on successful update, error code otherwise
908  */
909
910 static int gfs2_ri_update(struct gfs2_inode *ip)
911 {
912         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
913         int error;
914
915         do {
916                 error = read_rindex_entry(ip);
917         } while (error == 0);
918
919         if (error < 0)
920                 return error;
921
922         sdp->sd_rindex_uptodate = 1;
923         return 0;
924 }
925
926 /**
927  * gfs2_rindex_update - Update the rindex if required
928  * @sdp: The GFS2 superblock
929  *
930  * We grab a lock on the rindex inode to make sure that it doesn't
931  * change whilst we are performing an operation. We keep this lock
932  * for quite long periods of time compared to other locks. This
933  * doesn't matter, since it is shared and it is very, very rarely
934  * accessed in the exclusive mode (i.e. only when expanding the filesystem).
935  *
936  * This makes sure that we're using the latest copy of the resource index
937  * special file, which might have been updated if someone expanded the
938  * filesystem (via gfs2_grow utility), which adds new resource groups.
939  *
940  * Returns: 0 on succeess, error code otherwise
941  */
942
943 int gfs2_rindex_update(struct gfs2_sbd *sdp)
944 {
945         struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
946         struct gfs2_glock *gl = ip->i_gl;
947         struct gfs2_holder ri_gh;
948         int error = 0;
949         int unlock_required = 0;
950
951         /* Read new copy from disk if we don't have the latest */
952         if (!sdp->sd_rindex_uptodate) {
953                 if (!gfs2_glock_is_locked_by_me(gl)) {
954                         error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, &ri_gh);
955                         if (error)
956                                 return error;
957                         unlock_required = 1;
958                 }
959                 if (!sdp->sd_rindex_uptodate)
960                         error = gfs2_ri_update(ip);
961                 if (unlock_required)
962                         gfs2_glock_dq_uninit(&ri_gh);
963         }
964
965         return error;
966 }
967
968 static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
969 {
970         const struct gfs2_rgrp *str = buf;
971         u32 rg_flags;
972
973         rg_flags = be32_to_cpu(str->rg_flags);
974         rg_flags &= ~GFS2_RDF_MASK;
975         rgd->rd_flags &= GFS2_RDF_MASK;
976         rgd->rd_flags |= rg_flags;
977         rgd->rd_free = be32_to_cpu(str->rg_free);
978         rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
979         rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
980 }
981
982 static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
983 {
984         struct gfs2_rgrp *str = buf;
985
986         str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
987         str->rg_free = cpu_to_be32(rgd->rd_free);
988         str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
989         str->__pad = cpu_to_be32(0);
990         str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
991         memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
992 }
993
994 static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
995 {
996         struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
997         struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
998
999         if (rgl->rl_flags != str->rg_flags || rgl->rl_free != str->rg_free ||
1000             rgl->rl_dinodes != str->rg_dinodes ||
1001             rgl->rl_igeneration != str->rg_igeneration)
1002                 return 0;
1003         return 1;
1004 }
1005
1006 static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb *rgl, const void *buf)
1007 {
1008         const struct gfs2_rgrp *str = buf;
1009
1010         rgl->rl_magic = cpu_to_be32(GFS2_MAGIC);
1011         rgl->rl_flags = str->rg_flags;
1012         rgl->rl_free = str->rg_free;
1013         rgl->rl_dinodes = str->rg_dinodes;
1014         rgl->rl_igeneration = str->rg_igeneration;
1015         rgl->__pad = 0UL;
1016 }
1017
1018 static void update_rgrp_lvb_unlinked(struct gfs2_rgrpd *rgd, u32 change)
1019 {
1020         struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
1021         u32 unlinked = be32_to_cpu(rgl->rl_unlinked) + change;
1022         rgl->rl_unlinked = cpu_to_be32(unlinked);
1023 }
1024
1025 static u32 count_unlinked(struct gfs2_rgrpd *rgd)
1026 {
1027         struct gfs2_bitmap *bi;
1028         const u32 length = rgd->rd_length;
1029         const u8 *buffer = NULL;
1030         u32 i, goal, count = 0;
1031
1032         for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
1033                 goal = 0;
1034                 buffer = bi->bi_bh->b_data + bi->bi_offset;
1035                 WARN_ON(!buffer_uptodate(bi->bi_bh));
1036                 while (goal < bi->bi_len * GFS2_NBBY) {
1037                         goal = gfs2_bitfit(buffer, bi->bi_len, goal,
1038                                            GFS2_BLKST_UNLINKED);
1039                         if (goal == BFITNOENT)
1040                                 break;
1041                         count++;
1042                         goal++;
1043                 }
1044         }
1045
1046         return count;
1047 }
1048
1049
1050 /**
1051  * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
1052  * @rgd: the struct gfs2_rgrpd describing the RG to read in
1053  *
1054  * Read in all of a Resource Group's header and bitmap blocks.
1055  * Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.
1056  *
1057  * Returns: errno
1058  */
1059
1060 int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
1061 {
1062         struct gfs2_sbd *sdp = rgd->rd_sbd;
1063         struct gfs2_glock *gl = rgd->rd_gl;
1064         unsigned int length = rgd->rd_length;
1065         struct gfs2_bitmap *bi;
1066         unsigned int x, y;
1067         int error;
1068
1069         if (rgd->rd_bits[0].bi_bh != NULL)
1070                 return 0;
1071
1072         for (x = 0; x < length; x++) {
1073                 bi = rgd->rd_bits + x;
1074                 error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
1075                 if (error)
1076                         goto fail;
1077         }
1078
1079         for (y = length; y--;) {
1080                 bi = rgd->rd_bits + y;
1081                 error = gfs2_meta_wait(sdp, bi->bi_bh);
1082                 if (error)
1083                         goto fail;
1084                 if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
1085                                               GFS2_METATYPE_RG)) {
1086                         error = -EIO;
1087                         goto fail;
1088                 }
1089         }
1090
1091         if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
1092                 for (x = 0; x < length; x++)
1093                         clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
1094                 gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
1095                 rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
1096                 rgd->rd_free_clone = rgd->rd_free;
1097         }
1098         if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
1099                 rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
1100                 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
1101                                      rgd->rd_bits[0].bi_bh->b_data);
1102         }
1103         else if (sdp->sd_args.ar_rgrplvb) {
1104                 if (!gfs2_rgrp_lvb_valid(rgd)){
1105                         gfs2_consist_rgrpd(rgd);
1106                         error = -EIO;
1107                         goto fail;
1108                 }
1109                 if (rgd->rd_rgl->rl_unlinked == 0)
1110                         rgd->rd_flags &= ~GFS2_RDF_CHECK;
1111         }
1112         return 0;
1113
1114 fail:
1115         while (x--) {
1116                 bi = rgd->rd_bits + x;
1117                 brelse(bi->bi_bh);
1118                 bi->bi_bh = NULL;
1119                 gfs2_assert_warn(sdp, !bi->bi_clone);
1120         }
1121
1122         return error;
1123 }
1124
1125 int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
1126 {
1127         u32 rl_flags;
1128
1129         if (rgd->rd_flags & GFS2_RDF_UPTODATE)
1130                 return 0;
1131
1132         if (be32_to_cpu(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
1133                 return gfs2_rgrp_bh_get(rgd);
1134
1135         rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
1136         rl_flags &= ~GFS2_RDF_MASK;
1137         rgd->rd_flags &= GFS2_RDF_MASK;
1138         rgd->rd_flags |= (rl_flags | GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
1139         if (rgd->rd_rgl->rl_unlinked == 0)
1140                 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1141         rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
1142         rgd->rd_free_clone = rgd->rd_free;
1143         rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
1144         rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
1145         return 0;
1146 }
1147
1148 int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
1149 {
1150         struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1151         struct gfs2_sbd *sdp = rgd->rd_sbd;
1152
1153         if (gh->gh_flags & GL_SKIP && sdp->sd_args.ar_rgrplvb)
1154                 return 0;
1155         return gfs2_rgrp_bh_get((struct gfs2_rgrpd *)gh->gh_gl->gl_object);
1156 }
1157
1158 /**
1159  * gfs2_rgrp_go_unlock - Release RG bitmaps read in with gfs2_rgrp_bh_get()
1160  * @gh: The glock holder for the resource group
1161  *
1162  */
1163
1164 void gfs2_rgrp_go_unlock(struct gfs2_holder *gh)
1165 {
1166         struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1167         int x, length = rgd->rd_length;
1168
1169         for (x = 0; x < length; x++) {
1170                 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1171                 if (bi->bi_bh) {
1172                         brelse(bi->bi_bh);
1173                         bi->bi_bh = NULL;
1174                 }
1175         }
1176
1177 }
1178
1179 int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
1180                              struct buffer_head *bh,
1181                              const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
1182 {
1183         struct super_block *sb = sdp->sd_vfs;
1184         struct block_device *bdev = sb->s_bdev;
1185         const unsigned int sects_per_blk = sdp->sd_sb.sb_bsize /
1186                                            bdev_logical_block_size(sb->s_bdev);
1187         u64 blk;
1188         sector_t start = 0;
1189         sector_t nr_sects = 0;
1190         int rv;
1191         unsigned int x;
1192         u32 trimmed = 0;
1193         u8 diff;
1194
1195         for (x = 0; x < bi->bi_len; x++) {
1196                 const u8 *clone = bi->bi_clone ? bi->bi_clone : bi->bi_bh->b_data;
1197                 clone += bi->bi_offset;
1198                 clone += x;
1199                 if (bh) {
1200                         const u8 *orig = bh->b_data + bi->bi_offset + x;
1201                         diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));
1202                 } else {
1203                         diff = ~(*clone | (*clone >> 1));
1204                 }
1205                 diff &= 0x55;
1206                 if (diff == 0)
1207                         continue;
1208                 blk = offset + ((bi->bi_start + x) * GFS2_NBBY);
1209                 blk *= sects_per_blk; /* convert to sectors */
1210                 while(diff) {
1211                         if (diff & 1) {
1212                                 if (nr_sects == 0)
1213                                         goto start_new_extent;
1214                                 if ((start + nr_sects) != blk) {
1215                                         if (nr_sects >= minlen) {
1216                                                 rv = blkdev_issue_discard(bdev,
1217                                                         start, nr_sects,
1218                                                         GFP_NOFS, 0);
1219                                                 if (rv)
1220                                                         goto fail;
1221                                                 trimmed += nr_sects;
1222                                         }
1223                                         nr_sects = 0;
1224 start_new_extent:
1225                                         start = blk;
1226                                 }
1227                                 nr_sects += sects_per_blk;
1228                         }
1229                         diff >>= 2;
1230                         blk += sects_per_blk;
1231                 }
1232         }
1233         if (nr_sects >= minlen) {
1234                 rv = blkdev_issue_discard(bdev, start, nr_sects, GFP_NOFS, 0);
1235                 if (rv)
1236                         goto fail;
1237                 trimmed += nr_sects;
1238         }
1239         if (ptrimmed)
1240                 *ptrimmed = trimmed;
1241         return 0;
1242
1243 fail:
1244         if (sdp->sd_args.ar_discard)
1245                 fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem", rv);
1246         sdp->sd_args.ar_discard = 0;
1247         return -EIO;
1248 }
1249
1250 /**
1251  * gfs2_fitrim - Generate discard requests for unused bits of the filesystem
1252  * @filp: Any file on the filesystem
1253  * @argp: Pointer to the arguments (also used to pass result)
1254  *
1255  * Returns: 0 on success, otherwise error code
1256  */
1257
1258 int gfs2_fitrim(struct file *filp, void __user *argp)
1259 {
1260         struct inode *inode = filp->f_dentry->d_inode;
1261         struct gfs2_sbd *sdp = GFS2_SB(inode);
1262         struct request_queue *q = bdev_get_queue(sdp->sd_vfs->s_bdev);
1263         struct buffer_head *bh;
1264         struct gfs2_rgrpd *rgd;
1265         struct gfs2_rgrpd *rgd_end;
1266         struct gfs2_holder gh;
1267         struct fstrim_range r;
1268         int ret = 0;
1269         u64 amt;
1270         u64 trimmed = 0;
1271         u64 start, end, minlen;
1272         unsigned int x;
1273         unsigned bs_shift = sdp->sd_sb.sb_bsize_shift;
1274
1275         if (!capable(CAP_SYS_ADMIN))
1276                 return -EPERM;
1277
1278         if (!blk_queue_discard(q))
1279                 return -EOPNOTSUPP;
1280
1281         if (copy_from_user(&r, argp, sizeof(r)))
1282                 return -EFAULT;
1283
1284         ret = gfs2_rindex_update(sdp);
1285         if (ret)
1286                 return ret;
1287
1288         start = r.start >> bs_shift;
1289         end = start + (r.len >> bs_shift);
1290         minlen = max_t(u64, r.minlen,
1291                        q->limits.discard_granularity) >> bs_shift;
1292
1293         rgd = gfs2_blk2rgrpd(sdp, start, 0);
1294         rgd_end = gfs2_blk2rgrpd(sdp, end - 1, 0);
1295
1296         if (end <= start ||
1297             minlen > sdp->sd_max_rg_data ||
1298             start > rgd_end->rd_data0 + rgd_end->rd_data)
1299                 return -EINVAL;
1300
1301         while (1) {
1302
1303                 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
1304                 if (ret)
1305                         goto out;
1306
1307                 if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
1308                         /* Trim each bitmap in the rgrp */
1309                         for (x = 0; x < rgd->rd_length; x++) {
1310                                 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1311                                 ret = gfs2_rgrp_send_discards(sdp,
1312                                                 rgd->rd_data0, NULL, bi, minlen,
1313                                                 &amt);
1314                                 if (ret) {
1315                                         gfs2_glock_dq_uninit(&gh);
1316                                         goto out;
1317                                 }
1318                                 trimmed += amt;
1319                         }
1320
1321                         /* Mark rgrp as having been trimmed */
1322                         ret = gfs2_trans_begin(sdp, RES_RG_HDR, 0);
1323                         if (ret == 0) {
1324                                 bh = rgd->rd_bits[0].bi_bh;
1325                                 rgd->rd_flags |= GFS2_RGF_TRIMMED;
1326                                 gfs2_trans_add_meta(rgd->rd_gl, bh);
1327                                 gfs2_rgrp_out(rgd, bh->b_data);
1328                                 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, bh->b_data);
1329                                 gfs2_trans_end(sdp);
1330                         }
1331                 }
1332                 gfs2_glock_dq_uninit(&gh);
1333
1334                 if (rgd == rgd_end)
1335                         break;
1336
1337                 rgd = gfs2_rgrpd_get_next(rgd);
1338         }
1339
1340 out:
1341         r.len = trimmed << 9;
1342         if (copy_to_user(argp, &r, sizeof(r)))
1343                 return -EFAULT;
1344
1345         return ret;
1346 }
1347
1348 /**
1349  * rs_insert - insert a new multi-block reservation into the rgrp's rb_tree
1350  * @ip: the inode structure
1351  *
1352  */
1353 static void rs_insert(struct gfs2_inode *ip)
1354 {
1355         struct rb_node **newn, *parent = NULL;
1356         int rc;
1357         struct gfs2_blkreserv *rs = ip->i_res;
1358         struct gfs2_rgrpd *rgd = rs->rs_rbm.rgd;
1359         u64 fsblock = gfs2_rbm_to_block(&rs->rs_rbm);
1360
1361         BUG_ON(gfs2_rs_active(rs));
1362
1363         spin_lock(&rgd->rd_rsspin);
1364         newn = &rgd->rd_rstree.rb_node;
1365         while (*newn) {
1366                 struct gfs2_blkreserv *cur =
1367                         rb_entry(*newn, struct gfs2_blkreserv, rs_node);
1368
1369                 parent = *newn;
1370                 rc = rs_cmp(fsblock, rs->rs_free, cur);
1371                 if (rc > 0)
1372                         newn = &((*newn)->rb_right);
1373                 else if (rc < 0)
1374                         newn = &((*newn)->rb_left);
1375                 else {
1376                         spin_unlock(&rgd->rd_rsspin);
1377                         WARN_ON(1);
1378                         return;
1379                 }
1380         }
1381
1382         rb_link_node(&rs->rs_node, parent, newn);
1383         rb_insert_color(&rs->rs_node, &rgd->rd_rstree);
1384
1385         /* Do our rgrp accounting for the reservation */
1386         rgd->rd_reserved += rs->rs_free; /* blocks reserved */
1387         spin_unlock(&rgd->rd_rsspin);
1388         trace_gfs2_rs(rs, TRACE_RS_INSERT);
1389 }
1390
1391 /**
1392  * rg_mblk_search - find a group of multiple free blocks to form a reservation
1393  * @rgd: the resource group descriptor
1394  * @ip: pointer to the inode for which we're reserving blocks
1395  * @requested: number of blocks required for this allocation
1396  *
1397  */
1398
1399 static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
1400                            unsigned requested)
1401 {
1402         struct gfs2_rbm rbm = { .rgd = rgd, };
1403         u64 goal;
1404         struct gfs2_blkreserv *rs = ip->i_res;
1405         u32 extlen;
1406         u32 free_blocks = rgd->rd_free_clone - rgd->rd_reserved;
1407         int ret;
1408
1409         extlen = max_t(u32, atomic_read(&rs->rs_sizehint), requested);
1410         extlen = clamp(extlen, RGRP_RSRV_MINBLKS, free_blocks);
1411         if ((rgd->rd_free_clone < rgd->rd_reserved) || (free_blocks < extlen))
1412                 return;
1413
1414         /* Find bitmap block that contains bits for goal block */
1415         if (rgrp_contains_block(rgd, ip->i_goal))
1416                 goal = ip->i_goal;
1417         else
1418                 goal = rgd->rd_last_alloc + rgd->rd_data0;
1419
1420         if (WARN_ON(gfs2_rbm_from_block(&rbm, goal)))
1421                 return;
1422
1423         ret = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, extlen, ip, true);
1424         if (ret == 0) {
1425                 rs->rs_rbm = rbm;
1426                 rs->rs_free = extlen;
1427                 rs->rs_inum = ip->i_no_addr;
1428                 rs_insert(ip);
1429         } else {
1430                 if (goal == rgd->rd_last_alloc + rgd->rd_data0)
1431                         rgd->rd_last_alloc = 0;
1432         }
1433 }
1434
1435 /**
1436  * gfs2_next_unreserved_block - Return next block that is not reserved
1437  * @rgd: The resource group
1438  * @block: The starting block
1439  * @length: The required length
1440  * @ip: Ignore any reservations for this inode
1441  *
1442  * If the block does not appear in any reservation, then return the
1443  * block number unchanged. If it does appear in the reservation, then
1444  * keep looking through the tree of reservations in order to find the
1445  * first block number which is not reserved.
1446  */
1447
1448 static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
1449                                       u32 length,
1450                                       const struct gfs2_inode *ip)
1451 {
1452         struct gfs2_blkreserv *rs;
1453         struct rb_node *n;
1454         int rc;
1455
1456         spin_lock(&rgd->rd_rsspin);
1457         n = rgd->rd_rstree.rb_node;
1458         while (n) {
1459                 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1460                 rc = rs_cmp(block, length, rs);
1461                 if (rc < 0)
1462                         n = n->rb_left;
1463                 else if (rc > 0)
1464                         n = n->rb_right;
1465                 else
1466                         break;
1467         }
1468
1469         if (n) {
1470                 while ((rs_cmp(block, length, rs) == 0) && (ip->i_res != rs)) {
1471                         block = gfs2_rbm_to_block(&rs->rs_rbm) + rs->rs_free;
1472                         n = n->rb_right;
1473                         if (n == NULL)
1474                                 break;
1475                         rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1476                 }
1477         }
1478
1479         spin_unlock(&rgd->rd_rsspin);
1480         return block;
1481 }
1482
1483 /**
1484  * gfs2_reservation_check_and_update - Check for reservations during block alloc
1485  * @rbm: The current position in the resource group
1486  * @ip: The inode for which we are searching for blocks
1487  * @minext: The minimum extent length
1488  *
1489  * This checks the current position in the rgrp to see whether there is
1490  * a reservation covering this block. If not then this function is a
1491  * no-op. If there is, then the position is moved to the end of the
1492  * contiguous reservation(s) so that we are pointing at the first
1493  * non-reserved block.
1494  *
1495  * Returns: 0 if no reservation, 1 if @rbm has changed, otherwise an error
1496  */
1497
1498 static int gfs2_reservation_check_and_update(struct gfs2_rbm *rbm,
1499                                              const struct gfs2_inode *ip,
1500                                              u32 minext)
1501 {
1502         u64 block = gfs2_rbm_to_block(rbm);
1503         u32 extlen = 1;
1504         u64 nblock;
1505         int ret;
1506
1507         /*
1508          * If we have a minimum extent length, then skip over any extent
1509          * which is less than the min extent length in size.
1510          */
1511         if (minext) {
1512                 extlen = gfs2_free_extlen(rbm, minext);
1513                 nblock = block + extlen;
1514                 if (extlen < minext)
1515                         goto fail;
1516         }
1517
1518         /*
1519          * Check the extent which has been found against the reservations
1520          * and skip if parts of it are already reserved
1521          */
1522         nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, ip);
1523         if (nblock == block)
1524                 return 0;
1525 fail:
1526         ret = gfs2_rbm_from_block(rbm, nblock);
1527         if (ret < 0)
1528                 return ret;
1529         return 1;
1530 }
1531
1532 /**
1533  * gfs2_rbm_find - Look for blocks of a particular state
1534  * @rbm: Value/result starting position and final position
1535  * @state: The state which we want to find
1536  * @minext: The requested extent length (0 for a single block)
1537  * @ip: If set, check for reservations
1538  * @nowrap: Stop looking at the end of the rgrp, rather than wrapping
1539  *          around until we've reached the starting point.
1540  *
1541  * Side effects:
1542  * - If looking for free blocks, we set GBF_FULL on each bitmap which
1543  *   has no free blocks in it.
1544  *
1545  * Returns: 0 on success, -ENOSPC if there is no block of the requested state
1546  */
1547
1548 static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 minext,
1549                          const struct gfs2_inode *ip, bool nowrap)
1550 {
1551         struct buffer_head *bh;
1552         struct gfs2_bitmap *initial_bi;
1553         u32 initial_offset;
1554         u32 offset;
1555         u8 *buffer;
1556         int index;
1557         int n = 0;
1558         int iters = rbm->rgd->rd_length;
1559         int ret;
1560
1561         /* If we are not starting at the beginning of a bitmap, then we
1562          * need to add one to the bitmap count to ensure that we search
1563          * the starting bitmap twice.
1564          */
1565         if (rbm->offset != 0)
1566                 iters++;
1567
1568         while(1) {
1569                 if (test_bit(GBF_FULL, &rbm->bi->bi_flags) &&
1570                     (state == GFS2_BLKST_FREE))
1571                         goto next_bitmap;
1572
1573                 bh = rbm->bi->bi_bh;
1574                 buffer = bh->b_data + rbm->bi->bi_offset;
1575                 WARN_ON(!buffer_uptodate(bh));
1576                 if (state != GFS2_BLKST_UNLINKED && rbm->bi->bi_clone)
1577                         buffer = rbm->bi->bi_clone + rbm->bi->bi_offset;
1578                 initial_offset = rbm->offset;
1579                 offset = gfs2_bitfit(buffer, rbm->bi->bi_len, rbm->offset, state);
1580                 if (offset == BFITNOENT)
1581                         goto bitmap_full;
1582                 rbm->offset = offset;
1583                 if (ip == NULL)
1584                         return 0;
1585
1586                 initial_bi = rbm->bi;
1587                 ret = gfs2_reservation_check_and_update(rbm, ip, minext);
1588                 if (ret == 0)
1589                         return 0;
1590                 if (ret > 0) {
1591                         n += (rbm->bi - initial_bi);
1592                         goto next_iter;
1593                 }
1594                 if (ret == -E2BIG) {
1595                         index = 0;
1596                         rbm->offset = 0;
1597                         n += (rbm->bi - initial_bi);
1598                         goto res_covered_end_of_rgrp;
1599                 }
1600                 return ret;
1601
1602 bitmap_full:    /* Mark bitmap as full and fall through */
1603                 if ((state == GFS2_BLKST_FREE) && initial_offset == 0)
1604                         set_bit(GBF_FULL, &rbm->bi->bi_flags);
1605
1606 next_bitmap:    /* Find next bitmap in the rgrp */
1607                 rbm->offset = 0;
1608                 index = rbm->bi - rbm->rgd->rd_bits;
1609                 index++;
1610                 if (index == rbm->rgd->rd_length)
1611                         index = 0;
1612 res_covered_end_of_rgrp:
1613                 rbm->bi = &rbm->rgd->rd_bits[index];
1614                 if ((index == 0) && nowrap)
1615                         break;
1616                 n++;
1617 next_iter:
1618                 if (n >= iters)
1619                         break;
1620         }
1621
1622         return -ENOSPC;
1623 }
1624
1625 /**
1626  * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
1627  * @rgd: The rgrp
1628  * @last_unlinked: block address of the last dinode we unlinked
1629  * @skip: block address we should explicitly not unlink
1630  *
1631  * Returns: 0 if no error
1632  *          The inode, if one has been found, in inode.
1633  */
1634
1635 static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
1636 {
1637         u64 block;
1638         struct gfs2_sbd *sdp = rgd->rd_sbd;
1639         struct gfs2_glock *gl;
1640         struct gfs2_inode *ip;
1641         int error;
1642         int found = 0;
1643         struct gfs2_rbm rbm = { .rgd = rgd, .bi = rgd->rd_bits, .offset = 0 };
1644
1645         while (1) {
1646                 down_write(&sdp->sd_log_flush_lock);
1647                 error = gfs2_rbm_find(&rbm, GFS2_BLKST_UNLINKED, 0, NULL, true);
1648                 up_write(&sdp->sd_log_flush_lock);
1649                 if (error == -ENOSPC)
1650                         break;
1651                 if (WARN_ON_ONCE(error))
1652                         break;
1653
1654                 block = gfs2_rbm_to_block(&rbm);
1655                 if (gfs2_rbm_from_block(&rbm, block + 1))
1656                         break;
1657                 if (*last_unlinked != NO_BLOCK && block <= *last_unlinked)
1658                         continue;
1659                 if (block == skip)
1660                         continue;
1661                 *last_unlinked = block;
1662
1663                 error = gfs2_glock_get(sdp, block, &gfs2_inode_glops, CREATE, &gl);
1664                 if (error)
1665                         continue;
1666
1667                 /* If the inode is already in cache, we can ignore it here
1668                  * because the existing inode disposal code will deal with
1669                  * it when all refs have gone away. Accessing gl_object like
1670                  * this is not safe in general. Here it is ok because we do
1671                  * not dereference the pointer, and we only need an approx
1672                  * answer to whether it is NULL or not.
1673                  */
1674                 ip = gl->gl_object;
1675
1676                 if (ip || queue_work(gfs2_delete_workqueue, &gl->gl_delete) == 0)
1677                         gfs2_glock_put(gl);
1678                 else
1679                         found++;
1680
1681                 /* Limit reclaim to sensible number of tasks */
1682                 if (found > NR_CPUS)
1683                         return;
1684         }
1685
1686         rgd->rd_flags &= ~GFS2_RDF_CHECK;
1687         return;
1688 }
1689
1690 /**
1691  * gfs2_rgrp_congested - Use stats to figure out whether an rgrp is congested
1692  * @rgd: The rgrp in question
1693  * @loops: An indication of how picky we can be (0=very, 1=less so)
1694  *
1695  * This function uses the recently added glock statistics in order to
1696  * figure out whether a parciular resource group is suffering from
1697  * contention from multiple nodes. This is done purely on the basis
1698  * of timings, since this is the only data we have to work with and
1699  * our aim here is to reject a resource group which is highly contended
1700  * but (very important) not to do this too often in order to ensure that
1701  * we do not land up introducing fragmentation by changing resource
1702  * groups when not actually required.
1703  *
1704  * The calculation is fairly simple, we want to know whether the SRTTB
1705  * (i.e. smoothed round trip time for blocking operations) to acquire
1706  * the lock for this rgrp's glock is significantly greater than the
1707  * time taken for resource groups on average. We introduce a margin in
1708  * the form of the variable @var which is computed as the sum of the two
1709  * respective variences, and multiplied by a factor depending on @loops
1710  * and whether we have a lot of data to base the decision on. This is
1711  * then tested against the square difference of the means in order to
1712  * decide whether the result is statistically significant or not.
1713  *
1714  * Returns: A boolean verdict on the congestion status
1715  */
1716
1717 static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
1718 {
1719         const struct gfs2_glock *gl = rgd->rd_gl;
1720         const struct gfs2_sbd *sdp = gl->gl_sbd;
1721         struct gfs2_lkstats *st;
1722         s64 r_dcount, l_dcount;
1723         s64 r_srttb, l_srttb;
1724         s64 srttb_diff;
1725         s64 sqr_diff;
1726         s64 var;
1727
1728         preempt_disable();
1729         st = &this_cpu_ptr(sdp->sd_lkstats)->lkstats[LM_TYPE_RGRP];
1730         r_srttb = st->stats[GFS2_LKS_SRTTB];
1731         r_dcount = st->stats[GFS2_LKS_DCOUNT];
1732         var = st->stats[GFS2_LKS_SRTTVARB] +
1733               gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
1734         preempt_enable();
1735
1736         l_srttb = gl->gl_stats.stats[GFS2_LKS_SRTTB];
1737         l_dcount = gl->gl_stats.stats[GFS2_LKS_DCOUNT];
1738
1739         if ((l_dcount < 1) || (r_dcount < 1) || (r_srttb == 0))
1740                 return false;
1741
1742         srttb_diff = r_srttb - l_srttb;
1743         sqr_diff = srttb_diff * srttb_diff;
1744
1745         var *= 2;
1746         if (l_dcount < 8 || r_dcount < 8)
1747                 var *= 2;
1748         if (loops == 1)
1749                 var *= 2;
1750
1751         return ((srttb_diff < 0) && (sqr_diff > var));
1752 }
1753
1754 /**
1755  * gfs2_rgrp_used_recently
1756  * @rs: The block reservation with the rgrp to test
1757  * @msecs: The time limit in milliseconds
1758  *
1759  * Returns: True if the rgrp glock has been used within the time limit
1760  */
1761 static bool gfs2_rgrp_used_recently(const struct gfs2_blkreserv *rs,
1762                                     u64 msecs)
1763 {
1764         u64 tdiff;
1765
1766         tdiff = ktime_to_ns(ktime_sub(ktime_get_real(),
1767                             rs->rs_rbm.rgd->rd_gl->gl_dstamp));
1768
1769         return tdiff > (msecs * 1000 * 1000);
1770 }
1771
1772 static u32 gfs2_orlov_skip(const struct gfs2_inode *ip)
1773 {
1774         const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1775         u32 skip;
1776
1777         get_random_bytes(&skip, sizeof(skip));
1778         return skip % sdp->sd_rgrps;
1779 }
1780
1781 static bool gfs2_select_rgrp(struct gfs2_rgrpd **pos, const struct gfs2_rgrpd *begin)
1782 {
1783         struct gfs2_rgrpd *rgd = *pos;
1784         struct gfs2_sbd *sdp = rgd->rd_sbd;
1785
1786         rgd = gfs2_rgrpd_get_next(rgd);
1787         if (rgd == NULL)
1788                 rgd = gfs2_rgrpd_get_first(sdp);
1789         *pos = rgd;
1790         if (rgd != begin) /* If we didn't wrap */
1791                 return true;
1792         return false;
1793 }
1794
1795 /**
1796  * gfs2_inplace_reserve - Reserve space in the filesystem
1797  * @ip: the inode to reserve space for
1798  * @requested: the number of blocks to be reserved
1799  *
1800  * Returns: errno
1801  */
1802
1803 int gfs2_inplace_reserve(struct gfs2_inode *ip, u32 requested, u32 aflags)
1804 {
1805         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1806         struct gfs2_rgrpd *begin = NULL;
1807         struct gfs2_blkreserv *rs = ip->i_res;
1808         int error = 0, rg_locked, flags = 0;
1809         u64 last_unlinked = NO_BLOCK;
1810         int loops = 0;
1811         u32 skip = 0;
1812
1813         if (sdp->sd_args.ar_rgrplvb)
1814                 flags |= GL_SKIP;
1815         if (gfs2_assert_warn(sdp, requested))
1816                 return -EINVAL;
1817         if (gfs2_rs_active(rs)) {
1818                 begin = rs->rs_rbm.rgd;
1819                 flags = 0; /* Yoda: Do or do not. There is no try */
1820         } else if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, ip->i_goal)) {
1821                 rs->rs_rbm.rgd = begin = ip->i_rgd;
1822         } else {
1823                 rs->rs_rbm.rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
1824         }
1825         if (S_ISDIR(ip->i_inode.i_mode) && (aflags & GFS2_AF_ORLOV))
1826                 skip = gfs2_orlov_skip(ip);
1827         if (rs->rs_rbm.rgd == NULL)
1828                 return -EBADSLT;
1829
1830         while (loops < 3) {
1831                 rg_locked = 1;
1832
1833                 if (!gfs2_glock_is_locked_by_me(rs->rs_rbm.rgd->rd_gl)) {
1834                         rg_locked = 0;
1835                         if (skip && skip--)
1836                                 goto next_rgrp;
1837                         if (!gfs2_rs_active(rs) && (loops < 2) &&
1838                              gfs2_rgrp_used_recently(rs, 1000) &&
1839                              gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
1840                                 goto next_rgrp;
1841                         error = gfs2_glock_nq_init(rs->rs_rbm.rgd->rd_gl,
1842                                                    LM_ST_EXCLUSIVE, flags,
1843                                                    &rs->rs_rgd_gh);
1844                         if (unlikely(error))
1845                                 return error;
1846                         if (!gfs2_rs_active(rs) && (loops < 2) &&
1847                             gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
1848                                 goto skip_rgrp;
1849                         if (sdp->sd_args.ar_rgrplvb) {
1850                                 error = update_rgrp_lvb(rs->rs_rbm.rgd);
1851                                 if (unlikely(error)) {
1852                                         gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1853                                         return error;
1854                                 }
1855                         }
1856                 }
1857
1858                 /* Skip unuseable resource groups */
1859                 if (rs->rs_rbm.rgd->rd_flags & (GFS2_RGF_NOALLOC | GFS2_RDF_ERROR))
1860                         goto skip_rgrp;
1861
1862                 if (sdp->sd_args.ar_rgrplvb)
1863                         gfs2_rgrp_bh_get(rs->rs_rbm.rgd);
1864
1865                 /* Get a reservation if we don't already have one */
1866                 if (!gfs2_rs_active(rs))
1867                         rg_mblk_search(rs->rs_rbm.rgd, ip, requested);
1868
1869                 /* Skip rgrps when we can't get a reservation on first pass */
1870                 if (!gfs2_rs_active(rs) && (loops < 1))
1871                         goto check_rgrp;
1872
1873                 /* If rgrp has enough free space, use it */
1874                 if (rs->rs_rbm.rgd->rd_free_clone >= requested) {
1875                         ip->i_rgd = rs->rs_rbm.rgd;
1876                         return 0;
1877                 }
1878
1879                 /* Drop reservation, if we couldn't use reserved rgrp */
1880                 if (gfs2_rs_active(rs))
1881                         gfs2_rs_deltree(ip, rs);
1882 check_rgrp:
1883                 /* Check for unlinked inodes which can be reclaimed */
1884                 if (rs->rs_rbm.rgd->rd_flags & GFS2_RDF_CHECK)
1885                         try_rgrp_unlink(rs->rs_rbm.rgd, &last_unlinked,
1886                                         ip->i_no_addr);
1887 skip_rgrp:
1888                 /* Unlock rgrp if required */
1889                 if (!rg_locked)
1890                         gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1891 next_rgrp:
1892                 /* Find the next rgrp, and continue looking */
1893                 if (gfs2_select_rgrp(&rs->rs_rbm.rgd, begin))
1894                         continue;
1895                 if (skip)
1896                         continue;
1897
1898                 /* If we've scanned all the rgrps, but found no free blocks
1899                  * then this checks for some less likely conditions before
1900                  * trying again.
1901                  */
1902                 loops++;
1903                 /* Check that fs hasn't grown if writing to rindex */
1904                 if (ip == GFS2_I(sdp->sd_rindex) && !sdp->sd_rindex_uptodate) {
1905                         error = gfs2_ri_update(ip);
1906                         if (error)
1907                                 return error;
1908                 }
1909                 /* Flushing the log may release space */
1910                 if (loops == 2)
1911                         gfs2_log_flush(sdp, NULL);
1912         }
1913
1914         return -ENOSPC;
1915 }
1916
1917 /**
1918  * gfs2_inplace_release - release an inplace reservation
1919  * @ip: the inode the reservation was taken out on
1920  *
1921  * Release a reservation made by gfs2_inplace_reserve().
1922  */
1923
1924 void gfs2_inplace_release(struct gfs2_inode *ip)
1925 {
1926         struct gfs2_blkreserv *rs = ip->i_res;
1927
1928         if (rs->rs_rgd_gh.gh_gl)
1929                 gfs2_glock_dq_uninit(&rs->rs_rgd_gh);
1930 }
1931
1932 /**
1933  * gfs2_get_block_type - Check a block in a RG is of given type
1934  * @rgd: the resource group holding the block
1935  * @block: the block number
1936  *
1937  * Returns: The block type (GFS2_BLKST_*)
1938  */
1939
1940 static unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
1941 {
1942         struct gfs2_rbm rbm = { .rgd = rgd, };
1943         int ret;
1944
1945         ret = gfs2_rbm_from_block(&rbm, block);
1946         WARN_ON_ONCE(ret != 0);
1947
1948         return gfs2_testbit(&rbm);
1949 }
1950
1951
1952 /**
1953  * gfs2_alloc_extent - allocate an extent from a given bitmap
1954  * @rbm: the resource group information
1955  * @dinode: TRUE if the first block we allocate is for a dinode
1956  * @n: The extent length (value/result)
1957  *
1958  * Add the bitmap buffer to the transaction.
1959  * Set the found bits to @new_state to change block's allocation state.
1960  */
1961 static void gfs2_alloc_extent(const struct gfs2_rbm *rbm, bool dinode,
1962                              unsigned int *n)
1963 {
1964         struct gfs2_rbm pos = { .rgd = rbm->rgd, };
1965         const unsigned int elen = *n;
1966         u64 block;
1967         int ret;
1968
1969         *n = 1;
1970         block = gfs2_rbm_to_block(rbm);
1971         gfs2_trans_add_meta(rbm->rgd->rd_gl, rbm->bi->bi_bh);
1972         gfs2_setbit(rbm, true, dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
1973         block++;
1974         while (*n < elen) {
1975                 ret = gfs2_rbm_from_block(&pos, block);
1976                 if (ret || gfs2_testbit(&pos) != GFS2_BLKST_FREE)
1977                         break;
1978                 gfs2_trans_add_meta(pos.rgd->rd_gl, pos.bi->bi_bh);
1979                 gfs2_setbit(&pos, true, GFS2_BLKST_USED);
1980                 (*n)++;
1981                 block++;
1982         }
1983 }
1984
1985 /**
1986  * rgblk_free - Change alloc state of given block(s)
1987  * @sdp: the filesystem
1988  * @bstart: the start of a run of blocks to free
1989  * @blen: the length of the block run (all must lie within ONE RG!)
1990  * @new_state: GFS2_BLKST_XXX the after-allocation block state
1991  *
1992  * Returns:  Resource group containing the block(s)
1993  */
1994
1995 static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
1996                                      u32 blen, unsigned char new_state)
1997 {
1998         struct gfs2_rbm rbm;
1999
2000         rbm.rgd = gfs2_blk2rgrpd(sdp, bstart, 1);
2001         if (!rbm.rgd) {
2002                 if (gfs2_consist(sdp))
2003                         fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);
2004                 return NULL;
2005         }
2006
2007         while (blen--) {
2008                 gfs2_rbm_from_block(&rbm, bstart);
2009                 bstart++;
2010                 if (!rbm.bi->bi_clone) {
2011                         rbm.bi->bi_clone = kmalloc(rbm.bi->bi_bh->b_size,
2012                                                    GFP_NOFS | __GFP_NOFAIL);
2013                         memcpy(rbm.bi->bi_clone + rbm.bi->bi_offset,
2014                                rbm.bi->bi_bh->b_data + rbm.bi->bi_offset,
2015                                rbm.bi->bi_len);
2016                 }
2017                 gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.bi->bi_bh);
2018                 gfs2_setbit(&rbm, false, new_state);
2019         }
2020
2021         return rbm.rgd;
2022 }
2023
2024 /**
2025  * gfs2_rgrp_dump - print out an rgrp
2026  * @seq: The iterator
2027  * @gl: The glock in question
2028  *
2029  */
2030
2031 int gfs2_rgrp_dump(struct seq_file *seq, const struct gfs2_glock *gl)
2032 {
2033         struct gfs2_rgrpd *rgd = gl->gl_object;
2034         struct gfs2_blkreserv *trs;
2035         const struct rb_node *n;
2036
2037         if (rgd == NULL)
2038                 return 0;
2039         gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u r:%u\n",
2040                        (unsigned long long)rgd->rd_addr, rgd->rd_flags,
2041                        rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
2042                        rgd->rd_reserved);
2043         spin_lock(&rgd->rd_rsspin);
2044         for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
2045                 trs = rb_entry(n, struct gfs2_blkreserv, rs_node);
2046                 dump_rs(seq, trs);
2047         }
2048         spin_unlock(&rgd->rd_rsspin);
2049         return 0;
2050 }
2051
2052 static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
2053 {
2054         struct gfs2_sbd *sdp = rgd->rd_sbd;
2055         fs_warn(sdp, "rgrp %llu has an error, marking it readonly until umount\n",
2056                 (unsigned long long)rgd->rd_addr);
2057         fs_warn(sdp, "umount on all nodes and run fsck.gfs2 to fix the error\n");
2058         gfs2_rgrp_dump(NULL, rgd->rd_gl);
2059         rgd->rd_flags |= GFS2_RDF_ERROR;
2060 }
2061
2062 /**
2063  * gfs2_adjust_reservation - Adjust (or remove) a reservation after allocation
2064  * @ip: The inode we have just allocated blocks for
2065  * @rbm: The start of the allocated blocks
2066  * @len: The extent length
2067  *
2068  * Adjusts a reservation after an allocation has taken place. If the
2069  * reservation does not match the allocation, or if it is now empty
2070  * then it is removed.
2071  */
2072
2073 static void gfs2_adjust_reservation(struct gfs2_inode *ip,
2074                                     const struct gfs2_rbm *rbm, unsigned len)
2075 {
2076         struct gfs2_blkreserv *rs = ip->i_res;
2077         struct gfs2_rgrpd *rgd = rbm->rgd;
2078         unsigned rlen;
2079         u64 block;
2080         int ret;
2081
2082         spin_lock(&rgd->rd_rsspin);
2083         if (gfs2_rs_active(rs)) {
2084                 if (gfs2_rbm_eq(&rs->rs_rbm, rbm)) {
2085                         block = gfs2_rbm_to_block(rbm);
2086                         ret = gfs2_rbm_from_block(&rs->rs_rbm, block + len);
2087                         rlen = min(rs->rs_free, len);
2088                         rs->rs_free -= rlen;
2089                         rgd->rd_reserved -= rlen;
2090                         trace_gfs2_rs(rs, TRACE_RS_CLAIM);
2091                         if (rs->rs_free && !ret)
2092                                 goto out;
2093                 }
2094                 __rs_deltree(ip, rs);
2095         }
2096 out:
2097         spin_unlock(&rgd->rd_rsspin);
2098 }
2099
2100 /**
2101  * gfs2_alloc_blocks - Allocate one or more blocks of data and/or a dinode
2102  * @ip: the inode to allocate the block for
2103  * @bn: Used to return the starting block number
2104  * @nblocks: requested number of blocks/extent length (value/result)
2105  * @dinode: 1 if we're allocating a dinode block, else 0
2106  * @generation: the generation number of the inode
2107  *
2108  * Returns: 0 or error
2109  */
2110
2111 int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
2112                       bool dinode, u64 *generation)
2113 {
2114         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2115         struct buffer_head *dibh;
2116         struct gfs2_rbm rbm = { .rgd = ip->i_rgd, };
2117         unsigned int ndata;
2118         u64 goal;
2119         u64 block; /* block, within the file system scope */
2120         int error;
2121
2122         if (gfs2_rs_active(ip->i_res))
2123                 goal = gfs2_rbm_to_block(&ip->i_res->rs_rbm);
2124         else if (!dinode && rgrp_contains_block(rbm.rgd, ip->i_goal))
2125                 goal = ip->i_goal;
2126         else
2127                 goal = rbm.rgd->rd_last_alloc + rbm.rgd->rd_data0;
2128
2129         gfs2_rbm_from_block(&rbm, goal);
2130         error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, 0, ip, false);
2131
2132         if (error == -ENOSPC) {
2133                 gfs2_rbm_from_block(&rbm, goal);
2134                 error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, 0, NULL, false);
2135         }
2136
2137         /* Since all blocks are reserved in advance, this shouldn't happen */
2138         if (error) {
2139                 fs_warn(sdp, "inum=%llu error=%d, nblocks=%u, full=%d\n",
2140                         (unsigned long long)ip->i_no_addr, error, *nblocks,
2141                         test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags));
2142                 goto rgrp_error;
2143         }
2144
2145         gfs2_alloc_extent(&rbm, dinode, nblocks);
2146         block = gfs2_rbm_to_block(&rbm);
2147         rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
2148         if (gfs2_rs_active(ip->i_res))
2149                 gfs2_adjust_reservation(ip, &rbm, *nblocks);
2150         ndata = *nblocks;
2151         if (dinode)
2152                 ndata--;
2153
2154         if (!dinode) {
2155                 ip->i_goal = block + ndata - 1;
2156                 error = gfs2_meta_inode_buffer(ip, &dibh);
2157                 if (error == 0) {
2158                         struct gfs2_dinode *di =
2159                                 (struct gfs2_dinode *)dibh->b_data;
2160                         gfs2_trans_add_meta(ip->i_gl, dibh);
2161                         di->di_goal_meta = di->di_goal_data =
2162                                 cpu_to_be64(ip->i_goal);
2163                         brelse(dibh);
2164                 }
2165         }
2166         if (rbm.rgd->rd_free < *nblocks) {
2167                 printk(KERN_WARNING "nblocks=%u\n", *nblocks);
2168                 goto rgrp_error;
2169         }
2170
2171         rbm.rgd->rd_free -= *nblocks;
2172         if (dinode) {
2173                 rbm.rgd->rd_dinodes++;
2174                 *generation = rbm.rgd->rd_igeneration++;
2175                 if (*generation == 0)
2176                         *generation = rbm.rgd->rd_igeneration++;
2177         }
2178
2179         gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh);
2180         gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
2181         gfs2_rgrp_ondisk2lvb(rbm.rgd->rd_rgl, rbm.rgd->rd_bits[0].bi_bh->b_data);
2182
2183         gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
2184         if (dinode)
2185                 gfs2_trans_add_unrevoke(sdp, block, 1);
2186
2187         /*
2188          * This needs reviewing to see why we cannot do the quota change
2189          * at this point in the dinode case.
2190          */
2191         if (ndata)
2192                 gfs2_quota_change(ip, ndata, ip->i_inode.i_uid,
2193                                   ip->i_inode.i_gid);
2194
2195         rbm.rgd->rd_free_clone -= *nblocks;
2196         trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
2197                                dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
2198         *bn = block;
2199         return 0;
2200
2201 rgrp_error:
2202         gfs2_rgrp_error(rbm.rgd);
2203         return -EIO;
2204 }
2205
2206 /**
2207  * __gfs2_free_blocks - free a contiguous run of block(s)
2208  * @ip: the inode these blocks are being freed from
2209  * @bstart: first block of a run of contiguous blocks
2210  * @blen: the length of the block run
2211  * @meta: 1 if the blocks represent metadata
2212  *
2213  */
2214
2215 void __gfs2_free_blocks(struct gfs2_inode *ip, u64 bstart, u32 blen, int meta)
2216 {
2217         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2218         struct gfs2_rgrpd *rgd;
2219
2220         rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
2221         if (!rgd)
2222                 return;
2223         trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
2224         rgd->rd_free += blen;
2225         rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
2226         gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2227         gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2228         gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2229
2230         /* Directories keep their data in the metadata address space */
2231         if (meta || ip->i_depth)
2232                 gfs2_meta_wipe(ip, bstart, blen);
2233 }
2234
2235 /**
2236  * gfs2_free_meta - free a contiguous run of data block(s)
2237  * @ip: the inode these blocks are being freed from
2238  * @bstart: first block of a run of contiguous blocks
2239  * @blen: the length of the block run
2240  *
2241  */
2242
2243 void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)
2244 {
2245         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2246
2247         __gfs2_free_blocks(ip, bstart, blen, 1);
2248         gfs2_statfs_change(sdp, 0, +blen, 0);
2249         gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
2250 }
2251
2252 void gfs2_unlink_di(struct inode *inode)
2253 {
2254         struct gfs2_inode *ip = GFS2_I(inode);
2255         struct gfs2_sbd *sdp = GFS2_SB(inode);
2256         struct gfs2_rgrpd *rgd;
2257         u64 blkno = ip->i_no_addr;
2258
2259         rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);
2260         if (!rgd)
2261                 return;
2262         trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
2263         gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2264         gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2265         gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2266         update_rgrp_lvb_unlinked(rgd, 1);
2267 }
2268
2269 static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
2270 {
2271         struct gfs2_sbd *sdp = rgd->rd_sbd;
2272         struct gfs2_rgrpd *tmp_rgd;
2273
2274         tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE);
2275         if (!tmp_rgd)
2276                 return;
2277         gfs2_assert_withdraw(sdp, rgd == tmp_rgd);
2278
2279         if (!rgd->rd_dinodes)
2280                 gfs2_consist_rgrpd(rgd);
2281         rgd->rd_dinodes--;
2282         rgd->rd_free++;
2283
2284         gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2285         gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2286         gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, rgd->rd_bits[0].bi_bh->b_data);
2287         update_rgrp_lvb_unlinked(rgd, -1);
2288
2289         gfs2_statfs_change(sdp, 0, +1, -1);
2290 }
2291
2292
2293 void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
2294 {
2295         gfs2_free_uninit_di(rgd, ip->i_no_addr);
2296         trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
2297         gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
2298         gfs2_meta_wipe(ip, ip->i_no_addr, 1);
2299 }
2300
2301 /**
2302  * gfs2_check_blk_type - Check the type of a block
2303  * @sdp: The superblock
2304  * @no_addr: The block number to check
2305  * @type: The block type we are looking for
2306  *
2307  * Returns: 0 if the block type matches the expected type
2308  *          -ESTALE if it doesn't match
2309  *          or -ve errno if something went wrong while checking
2310  */
2311
2312 int gfs2_check_blk_type(struct gfs2_sbd *sdp, u64 no_addr, unsigned int type)
2313 {
2314         struct gfs2_rgrpd *rgd;
2315         struct gfs2_holder rgd_gh;
2316         int error = -EINVAL;
2317
2318         rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
2319         if (!rgd)
2320                 goto fail;
2321
2322         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
2323         if (error)
2324                 goto fail;
2325
2326         if (gfs2_get_block_type(rgd, no_addr) != type)
2327                 error = -ESTALE;
2328
2329         gfs2_glock_dq_uninit(&rgd_gh);
2330 fail:
2331         return error;
2332 }
2333
2334 /**
2335  * gfs2_rlist_add - add a RG to a list of RGs
2336  * @ip: the inode
2337  * @rlist: the list of resource groups
2338  * @block: the block
2339  *
2340  * Figure out what RG a block belongs to and add that RG to the list
2341  *
2342  * FIXME: Don't use NOFAIL
2343  *
2344  */
2345
2346 void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
2347                     u64 block)
2348 {
2349         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2350         struct gfs2_rgrpd *rgd;
2351         struct gfs2_rgrpd **tmp;
2352         unsigned int new_space;
2353         unsigned int x;
2354
2355         if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
2356                 return;
2357
2358         if (ip->i_rgd && rgrp_contains_block(ip->i_rgd, block))
2359                 rgd = ip->i_rgd;
2360         else
2361                 rgd = gfs2_blk2rgrpd(sdp, block, 1);
2362         if (!rgd) {
2363                 fs_err(sdp, "rlist_add: no rgrp for block %llu\n", (unsigned long long)block);
2364                 return;
2365         }
2366         ip->i_rgd = rgd;
2367
2368         for (x = 0; x < rlist->rl_rgrps; x++)
2369                 if (rlist->rl_rgd[x] == rgd)
2370                         return;
2371
2372         if (rlist->rl_rgrps == rlist->rl_space) {
2373                 new_space = rlist->rl_space + 10;
2374
2375                 tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
2376                               GFP_NOFS | __GFP_NOFAIL);
2377
2378                 if (rlist->rl_rgd) {
2379                         memcpy(tmp, rlist->rl_rgd,
2380                                rlist->rl_space * sizeof(struct gfs2_rgrpd *));
2381                         kfree(rlist->rl_rgd);
2382                 }
2383
2384                 rlist->rl_space = new_space;
2385                 rlist->rl_rgd = tmp;
2386         }
2387
2388         rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
2389 }
2390
2391 /**
2392  * gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
2393  *      and initialize an array of glock holders for them
2394  * @rlist: the list of resource groups
2395  * @state: the lock state to acquire the RG lock in
2396  *
2397  * FIXME: Don't use NOFAIL
2398  *
2399  */
2400
2401 void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state)
2402 {
2403         unsigned int x;
2404
2405         rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder),
2406                                 GFP_NOFS | __GFP_NOFAIL);
2407         for (x = 0; x < rlist->rl_rgrps; x++)
2408                 gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
2409                                 state, 0,
2410                                 &rlist->rl_ghs[x]);
2411 }
2412
2413 /**
2414  * gfs2_rlist_free - free a resource group list
2415  * @list: the list of resource groups
2416  *
2417  */
2418
2419 void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
2420 {
2421         unsigned int x;
2422
2423         kfree(rlist->rl_rgd);
2424
2425         if (rlist->rl_ghs) {
2426                 for (x = 0; x < rlist->rl_rgrps; x++)
2427                         gfs2_holder_uninit(&rlist->rl_ghs[x]);
2428                 kfree(rlist->rl_ghs);
2429                 rlist->rl_ghs = NULL;
2430         }
2431 }
2432