[GFS2] Add an additional argument to gfs2_trans_add_bh()
[linux-2.6] / fs / gfs2 / rgrp.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2005 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 v.2.
8  */
9
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <asm/semaphore.h>
16
17 #include "gfs2.h"
18 #include "bits.h"
19 #include "glock.h"
20 #include "glops.h"
21 #include "jdata.h"
22 #include "lops.h"
23 #include "meta_io.h"
24 #include "quota.h"
25 #include "rgrp.h"
26 #include "super.h"
27 #include "trans.h"
28
29 /**
30  * gfs2_rgrp_verify - Verify that a resource group is consistent
31  * @sdp: the filesystem
32  * @rgd: the rgrp
33  *
34  */
35
36 void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
37 {
38         struct gfs2_sbd *sdp = rgd->rd_sbd;
39         struct gfs2_bitmap *bi = NULL;
40         uint32_t length = rgd->rd_ri.ri_length;
41         uint32_t count[4], tmp;
42         int buf, x;
43
44         memset(count, 0, 4 * sizeof(uint32_t));
45
46         /* Count # blocks in each of 4 possible allocation states */
47         for (buf = 0; buf < length; buf++) {
48                 bi = rgd->rd_bits + buf;
49                 for (x = 0; x < 4; x++)
50                         count[x] += gfs2_bitcount(rgd,
51                                                   bi->bi_bh->b_data +
52                                                   bi->bi_offset,
53                                                   bi->bi_len, x);
54         }
55
56         if (count[0] != rgd->rd_rg.rg_free) {
57                 if (gfs2_consist_rgrpd(rgd))
58                         fs_err(sdp, "free data mismatch:  %u != %u\n",
59                                count[0], rgd->rd_rg.rg_free);
60                 return;
61         }
62
63         tmp = rgd->rd_ri.ri_data -
64                 rgd->rd_rg.rg_free -
65                 rgd->rd_rg.rg_dinodes;
66         if (count[1] != tmp) {
67                 if (gfs2_consist_rgrpd(rgd))
68                         fs_err(sdp, "used data mismatch:  %u != %u\n",
69                                count[1], tmp);
70                 return;
71         }
72
73         if (count[2]) {
74                 if (gfs2_consist_rgrpd(rgd))
75                         fs_err(sdp, "free metadata mismatch:  %u != 0\n",
76                                count[2]);
77                 return;
78         }
79
80         if (count[3] != rgd->rd_rg.rg_dinodes) {
81                 if (gfs2_consist_rgrpd(rgd))
82                         fs_err(sdp, "used metadata mismatch:  %u != %u\n",
83                                count[3], rgd->rd_rg.rg_dinodes);
84                 return;
85         }
86 }
87
88 static inline int rgrp_contains_block(struct gfs2_rindex *ri, uint64_t block)
89 {
90         uint64_t first = ri->ri_data0;
91         uint64_t last = first + ri->ri_data;
92         return !!(first <= block && block < last);
93 }
94
95 /**
96  * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
97  * @sdp: The GFS2 superblock
98  * @n: The data block number
99  *
100  * Returns: The resource group, or NULL if not found
101  */
102
103 struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, uint64_t blk)
104 {
105         struct gfs2_rgrpd *rgd;
106
107         spin_lock(&sdp->sd_rindex_spin);
108
109         list_for_each_entry(rgd, &sdp->sd_rindex_mru_list, rd_list_mru) {
110                 if (rgrp_contains_block(&rgd->rd_ri, blk)) {
111                         list_move(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);
112                         spin_unlock(&sdp->sd_rindex_spin);
113                         return rgd;
114                 }
115         }
116
117         spin_unlock(&sdp->sd_rindex_spin);
118
119         return NULL;
120 }
121
122 /**
123  * gfs2_rgrpd_get_first - get the first Resource Group in the filesystem
124  * @sdp: The GFS2 superblock
125  *
126  * Returns: The first rgrp in the filesystem
127  */
128
129 struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp)
130 {
131         gfs2_assert(sdp, !list_empty(&sdp->sd_rindex_list));
132         return list_entry(sdp->sd_rindex_list.next, struct gfs2_rgrpd, rd_list);
133 }
134
135 /**
136  * gfs2_rgrpd_get_next - get the next RG
137  * @rgd: A RG
138  *
139  * Returns: The next rgrp
140  */
141
142 struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
143 {
144         if (rgd->rd_list.next == &rgd->rd_sbd->sd_rindex_list)
145                 return NULL;
146         return list_entry(rgd->rd_list.next, struct gfs2_rgrpd, rd_list);
147 }
148
149 static void clear_rgrpdi(struct gfs2_sbd *sdp)
150 {
151         struct list_head *head;
152         struct gfs2_rgrpd *rgd;
153         struct gfs2_glock *gl;
154
155         spin_lock(&sdp->sd_rindex_spin);
156         sdp->sd_rindex_forward = NULL;
157         head = &sdp->sd_rindex_recent_list;
158         while (!list_empty(head)) {
159                 rgd = list_entry(head->next, struct gfs2_rgrpd, rd_recent);
160                 list_del(&rgd->rd_recent);
161         }
162         spin_unlock(&sdp->sd_rindex_spin);
163
164         head = &sdp->sd_rindex_list;
165         while (!list_empty(head)) {
166                 rgd = list_entry(head->next, struct gfs2_rgrpd, rd_list);
167                 gl = rgd->rd_gl;
168
169                 list_del(&rgd->rd_list);
170                 list_del(&rgd->rd_list_mru);
171
172                 if (gl) {
173                         set_gl2rgd(gl, NULL);
174                         gfs2_glock_put(gl);
175                 }
176
177                 kfree(rgd->rd_bits);
178                 kfree(rgd);
179         }
180 }
181
182 void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
183 {
184         down(&sdp->sd_rindex_mutex);
185         clear_rgrpdi(sdp);
186         up(&sdp->sd_rindex_mutex);
187 }
188
189 /**
190  * gfs2_compute_bitstructs - Compute the bitmap sizes
191  * @rgd: The resource group descriptor
192  *
193  * Calculates bitmap descriptors, one for each block that contains bitmap data
194  *
195  * Returns: errno
196  */
197
198 static int compute_bitstructs(struct gfs2_rgrpd *rgd)
199 {
200         struct gfs2_sbd *sdp = rgd->rd_sbd;
201         struct gfs2_bitmap *bi;
202         uint32_t length = rgd->rd_ri.ri_length; /* # blocks in hdr & bitmap */
203         uint32_t bytes_left, bytes;
204         int x;
205
206         rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_KERNEL);
207         if (!rgd->rd_bits)
208                 return -ENOMEM;
209
210         bytes_left = rgd->rd_ri.ri_bitbytes;
211
212         for (x = 0; x < length; x++) {
213                 bi = rgd->rd_bits + x;
214
215                 /* small rgrp; bitmap stored completely in header block */
216                 if (length == 1) {
217                         bytes = bytes_left;
218                         bi->bi_offset = sizeof(struct gfs2_rgrp);
219                         bi->bi_start = 0;
220                         bi->bi_len = bytes;
221                 /* header block */
222                 } else if (x == 0) {
223                         bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
224                         bi->bi_offset = sizeof(struct gfs2_rgrp);
225                         bi->bi_start = 0;
226                         bi->bi_len = bytes;
227                 /* last block */
228                 } else if (x + 1 == length) {
229                         bytes = bytes_left;
230                         bi->bi_offset = sizeof(struct gfs2_meta_header);
231                         bi->bi_start = rgd->rd_ri.ri_bitbytes - bytes_left;
232                         bi->bi_len = bytes;
233                 /* other blocks */
234                 } else {
235                         bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
236                         bi->bi_offset = sizeof(struct gfs2_meta_header);
237                         bi->bi_start = rgd->rd_ri.ri_bitbytes - bytes_left;
238                         bi->bi_len = bytes;
239                 }
240
241                 bytes_left -= bytes;
242         }
243
244         if (bytes_left) {
245                 gfs2_consist_rgrpd(rgd);
246                 return -EIO;
247         }
248         bi = rgd->rd_bits + (length - 1);
249         if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_ri.ri_data) {
250                 if (gfs2_consist_rgrpd(rgd)) {
251                         gfs2_rindex_print(&rgd->rd_ri);
252                         fs_err(sdp, "start=%u len=%u offset=%u\n",
253                                bi->bi_start, bi->bi_len, bi->bi_offset);
254                 }
255                 return -EIO;
256         }
257
258         return 0;
259 }
260
261 /**
262  * gfs2_ri_update - Pull in a new resource index from the disk
263  * @gl: The glock covering the rindex inode
264  *
265  * Returns: 0 on successful update, error code otherwise
266  */
267
268 static int gfs2_ri_update(struct gfs2_inode *ip)
269 {
270         struct gfs2_sbd *sdp = ip->i_sbd;
271         struct gfs2_rgrpd *rgd;
272         char buf[sizeof(struct gfs2_rindex)];
273         uint64_t junk = ip->i_di.di_size;
274         int error;
275
276         if (do_div(junk, sizeof(struct gfs2_rindex))) {
277                 gfs2_consist_inode(ip);
278                 return -EIO;
279         }
280
281         clear_rgrpdi(sdp);
282
283         for (sdp->sd_rgrps = 0;; sdp->sd_rgrps++) {
284                 error = gfs2_jdata_read_mem(ip, buf,
285                                             sdp->sd_rgrps *
286                                             sizeof(struct gfs2_rindex),
287                                             sizeof(struct gfs2_rindex));
288                 if (!error)
289                         break;
290                 if (error != sizeof(struct gfs2_rindex)) {
291                         if (error > 0)
292                                 error = -EIO;
293                         goto fail;
294                 }
295
296                 rgd = kzalloc(sizeof(struct gfs2_rgrpd), GFP_KERNEL);
297                 error = -ENOMEM;
298                 if (!rgd)
299                         goto fail;
300
301                 init_MUTEX(&rgd->rd_mutex);
302                 lops_init_le(&rgd->rd_le, &gfs2_rg_lops);
303                 rgd->rd_sbd = sdp;
304
305                 list_add_tail(&rgd->rd_list, &sdp->sd_rindex_list);
306                 list_add_tail(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);
307
308                 gfs2_rindex_in(&rgd->rd_ri, buf);
309
310                 error = compute_bitstructs(rgd);
311                 if (error)
312                         goto fail;
313
314                 error = gfs2_glock_get(sdp, rgd->rd_ri.ri_addr,
315                                        &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
316                 if (error)
317                         goto fail;
318
319                 set_gl2rgd(rgd->rd_gl, rgd);
320                 rgd->rd_rg_vn = rgd->rd_gl->gl_vn - 1;
321         }
322
323         sdp->sd_rindex_vn = ip->i_gl->gl_vn;
324
325         return 0;
326
327  fail:
328         clear_rgrpdi(sdp);
329
330         return error;
331 }
332
333 /**
334  * gfs2_rindex_hold - Grab a lock on the rindex
335  * @sdp: The GFS2 superblock
336  * @ri_gh: the glock holder
337  *
338  * We grab a lock on the rindex inode to make sure that it doesn't
339  * change whilst we are performing an operation. We keep this lock
340  * for quite long periods of time compared to other locks. This
341  * doesn't matter, since it is shared and it is very, very rarely
342  * accessed in the exclusive mode (i.e. only when expanding the filesystem).
343  *
344  * This makes sure that we're using the latest copy of the resource index
345  * special file, which might have been updated if someone expanded the
346  * filesystem (via gfs2_grow utility), which adds new resource groups.
347  *
348  * Returns: 0 on success, error code otherwise
349  */
350
351 int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh)
352 {
353         struct gfs2_inode *ip = sdp->sd_rindex;
354         struct gfs2_glock *gl = ip->i_gl;
355         int error;
356
357         error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, ri_gh);
358         if (error)
359                 return error;
360
361         /* Read new copy from disk if we don't have the latest */
362         if (sdp->sd_rindex_vn != gl->gl_vn) {
363                 down(&sdp->sd_rindex_mutex);
364                 if (sdp->sd_rindex_vn != gl->gl_vn) {
365                         error = gfs2_ri_update(ip);
366                         if (error)
367                                 gfs2_glock_dq_uninit(ri_gh);
368                 }
369                 up(&sdp->sd_rindex_mutex);
370         }
371
372         return error;
373 }
374
375 /**
376  * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
377  * @rgd: the struct gfs2_rgrpd describing the RG to read in
378  *
379  * Read in all of a Resource Group's header and bitmap blocks.
380  * Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.
381  *
382  * Returns: errno
383  */
384
385 int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
386 {
387         struct gfs2_sbd *sdp = rgd->rd_sbd;
388         struct gfs2_glock *gl = rgd->rd_gl;
389         unsigned int length = rgd->rd_ri.ri_length;
390         struct gfs2_bitmap *bi;
391         unsigned int x, y;
392         int error;
393
394         down(&rgd->rd_mutex);
395
396         spin_lock(&sdp->sd_rindex_spin);
397         if (rgd->rd_bh_count) {
398                 rgd->rd_bh_count++;
399                 spin_unlock(&sdp->sd_rindex_spin);
400                 up(&rgd->rd_mutex);
401                 return 0;
402         }
403         spin_unlock(&sdp->sd_rindex_spin);
404
405         for (x = 0; x < length; x++) {
406                 bi = rgd->rd_bits + x;
407                 error = gfs2_meta_read(gl, rgd->rd_ri.ri_addr + x, DIO_START,
408                                        &bi->bi_bh);
409                 if (error)
410                         goto fail;
411         }
412
413         for (y = length; y--;) {
414                 bi = rgd->rd_bits + y;
415                 error = gfs2_meta_reread(sdp, bi->bi_bh, DIO_WAIT);
416                 if (error)
417                         goto fail;
418                 if (gfs2_metatype_check(sdp, bi->bi_bh,
419                                         (y) ? GFS2_METATYPE_RB :
420                                               GFS2_METATYPE_RG)) {
421                         error = -EIO;
422                         goto fail;
423                 }
424         }
425
426         if (rgd->rd_rg_vn != gl->gl_vn) {
427                 gfs2_rgrp_in(&rgd->rd_rg, (rgd->rd_bits[0].bi_bh)->b_data);
428                 rgd->rd_rg_vn = gl->gl_vn;
429         }
430
431         spin_lock(&sdp->sd_rindex_spin);
432         rgd->rd_free_clone = rgd->rd_rg.rg_free;
433         rgd->rd_bh_count++;
434         spin_unlock(&sdp->sd_rindex_spin);
435
436         up(&rgd->rd_mutex);
437
438         return 0;
439
440  fail:
441         while (x--) {
442                 bi = rgd->rd_bits + x;
443                 brelse(bi->bi_bh);
444                 bi->bi_bh = NULL;
445                 gfs2_assert_warn(sdp, !bi->bi_clone);
446         }
447         up(&rgd->rd_mutex);
448
449         return error;
450 }
451
452 void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd)
453 {
454         struct gfs2_sbd *sdp = rgd->rd_sbd;
455
456         spin_lock(&sdp->sd_rindex_spin);
457         gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count);
458         rgd->rd_bh_count++;
459         spin_unlock(&sdp->sd_rindex_spin);
460 }
461
462 /**
463  * gfs2_rgrp_bh_put - Release RG bitmaps read in with gfs2_rgrp_bh_get()
464  * @rgd: the struct gfs2_rgrpd describing the RG to read in
465  *
466  */
467
468 void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd)
469 {
470         struct gfs2_sbd *sdp = rgd->rd_sbd;
471         int x, length = rgd->rd_ri.ri_length;
472
473         spin_lock(&sdp->sd_rindex_spin);
474         gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count);
475         if (--rgd->rd_bh_count) {
476                 spin_unlock(&sdp->sd_rindex_spin);
477                 return;
478         }
479
480         for (x = 0; x < length; x++) {
481                 struct gfs2_bitmap *bi = rgd->rd_bits + x;
482                 kfree(bi->bi_clone);
483                 bi->bi_clone = NULL;
484                 brelse(bi->bi_bh);
485                 bi->bi_bh = NULL;
486         }
487
488         spin_unlock(&sdp->sd_rindex_spin);
489 }
490
491 void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd)
492 {
493         struct gfs2_sbd *sdp = rgd->rd_sbd;
494         unsigned int length = rgd->rd_ri.ri_length;
495         unsigned int x;
496
497         for (x = 0; x < length; x++) {
498                 struct gfs2_bitmap *bi = rgd->rd_bits + x;
499                 if (!bi->bi_clone)
500                         continue;
501                 memcpy(bi->bi_clone + bi->bi_offset,
502                        bi->bi_bh->b_data + bi->bi_offset,
503                        bi->bi_len);
504         }
505
506         spin_lock(&sdp->sd_rindex_spin);
507         rgd->rd_free_clone = rgd->rd_rg.rg_free;
508         spin_unlock(&sdp->sd_rindex_spin);
509 }
510
511 /**
512  * gfs2_alloc_get - get the struct gfs2_alloc structure for an inode
513  * @ip: the incore GFS2 inode structure
514  *
515  * Returns: the struct gfs2_alloc
516  */
517
518 struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip)
519 {
520         struct gfs2_alloc *al = &ip->i_alloc;
521
522         /* FIXME: Should assert that the correct locks are held here... */
523         memset(al, 0, sizeof(*al));
524         return al;
525 }
526
527 /**
528  * gfs2_alloc_put - throw away the struct gfs2_alloc for an inode
529  * @ip: the inode
530  *
531  */
532
533 void gfs2_alloc_put(struct gfs2_inode *ip)
534 {
535         return;
536 }
537
538 /**
539  * try_rgrp_fit - See if a given reservation will fit in a given RG
540  * @rgd: the RG data
541  * @al: the struct gfs2_alloc structure describing the reservation
542  *
543  * If there's room for the requested blocks to be allocated from the RG:
544  *   Sets the $al_reserved_data field in @al.
545  *   Sets the $al_reserved_meta field in @al.
546  *   Sets the $al_rgd field in @al.
547  *
548  * Returns: 1 on success (it fits), 0 on failure (it doesn't fit)
549  */
550
551 static int try_rgrp_fit(struct gfs2_rgrpd *rgd, struct gfs2_alloc *al)
552 {
553         struct gfs2_sbd *sdp = rgd->rd_sbd;
554         int ret = 0;
555
556         spin_lock(&sdp->sd_rindex_spin);
557         if (rgd->rd_free_clone >= al->al_requested) {
558                 al->al_rgd = rgd;
559                 ret = 1;
560         }
561         spin_unlock(&sdp->sd_rindex_spin);
562
563         return ret;
564 }
565
566 /**
567  * recent_rgrp_first - get first RG from "recent" list
568  * @sdp: The GFS2 superblock
569  * @rglast: address of the rgrp used last
570  *
571  * Returns: The first rgrp in the recent list
572  */
573
574 static struct gfs2_rgrpd *recent_rgrp_first(struct gfs2_sbd *sdp,
575                                             uint64_t rglast)
576 {
577         struct gfs2_rgrpd *rgd = NULL;
578
579         spin_lock(&sdp->sd_rindex_spin);
580
581         if (list_empty(&sdp->sd_rindex_recent_list))
582                 goto out;
583
584         if (!rglast)
585                 goto first;
586
587         list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) {
588                 if (rgd->rd_ri.ri_addr == rglast)
589                         goto out;
590         }
591
592  first:
593         rgd = list_entry(sdp->sd_rindex_recent_list.next, struct gfs2_rgrpd,
594                          rd_recent);
595
596  out:
597         spin_unlock(&sdp->sd_rindex_spin);
598
599         return rgd;
600 }
601
602 /**
603  * recent_rgrp_next - get next RG from "recent" list
604  * @cur_rgd: current rgrp
605  * @remove:
606  *
607  * Returns: The next rgrp in the recent list
608  */
609
610 static struct gfs2_rgrpd *recent_rgrp_next(struct gfs2_rgrpd *cur_rgd,
611                                            int remove)
612 {
613         struct gfs2_sbd *sdp = cur_rgd->rd_sbd;
614         struct list_head *head;
615         struct gfs2_rgrpd *rgd;
616
617         spin_lock(&sdp->sd_rindex_spin);
618
619         head = &sdp->sd_rindex_recent_list;
620
621         list_for_each_entry(rgd, head, rd_recent) {
622                 if (rgd == cur_rgd) {
623                         if (cur_rgd->rd_recent.next != head)
624                                 rgd = list_entry(cur_rgd->rd_recent.next,
625                                                  struct gfs2_rgrpd, rd_recent);
626                         else
627                                 rgd = NULL;
628
629                         if (remove)
630                                 list_del(&cur_rgd->rd_recent);
631
632                         goto out;
633                 }
634         }
635
636         rgd = NULL;
637         if (!list_empty(head))
638                 rgd = list_entry(head->next, struct gfs2_rgrpd, rd_recent);
639
640  out:
641         spin_unlock(&sdp->sd_rindex_spin);
642
643         return rgd;
644 }
645
646 /**
647  * recent_rgrp_add - add an RG to tail of "recent" list
648  * @new_rgd: The rgrp to add
649  *
650  */
651
652 static void recent_rgrp_add(struct gfs2_rgrpd *new_rgd)
653 {
654         struct gfs2_sbd *sdp = new_rgd->rd_sbd;
655         struct gfs2_rgrpd *rgd;
656         unsigned int count = 0;
657         unsigned int max = sdp->sd_rgrps / gfs2_jindex_size(sdp);
658
659         spin_lock(&sdp->sd_rindex_spin);
660
661         list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) {
662                 if (rgd == new_rgd)
663                         goto out;
664
665                 if (++count >= max)
666                         goto out;
667         }
668         list_add_tail(&new_rgd->rd_recent, &sdp->sd_rindex_recent_list);
669
670  out:
671         spin_unlock(&sdp->sd_rindex_spin);
672 }
673
674 /**
675  * forward_rgrp_get - get an rgrp to try next from full list
676  * @sdp: The GFS2 superblock
677  *
678  * Returns: The rgrp to try next
679  */
680
681 static struct gfs2_rgrpd *forward_rgrp_get(struct gfs2_sbd *sdp)
682 {
683         struct gfs2_rgrpd *rgd;
684         unsigned int journals = gfs2_jindex_size(sdp);
685         unsigned int rg = 0, x;
686
687         spin_lock(&sdp->sd_rindex_spin);
688
689         rgd = sdp->sd_rindex_forward;
690         if (!rgd) {
691                 if (sdp->sd_rgrps >= journals)
692                         rg = sdp->sd_rgrps * sdp->sd_jdesc->jd_jid / journals;
693
694                 for (x = 0, rgd = gfs2_rgrpd_get_first(sdp);
695                      x < rg;
696                      x++, rgd = gfs2_rgrpd_get_next(rgd))
697                         /* Do Nothing */;
698
699                 sdp->sd_rindex_forward = rgd;
700         }
701
702         spin_unlock(&sdp->sd_rindex_spin);
703
704         return rgd;
705 }
706
707 /**
708  * forward_rgrp_set - set the forward rgrp pointer
709  * @sdp: the filesystem
710  * @rgd: The new forward rgrp
711  *
712  */
713
714 static void forward_rgrp_set(struct gfs2_sbd *sdp, struct gfs2_rgrpd *rgd)
715 {
716         spin_lock(&sdp->sd_rindex_spin);
717         sdp->sd_rindex_forward = rgd;
718         spin_unlock(&sdp->sd_rindex_spin);
719 }
720
721 /**
722  * get_local_rgrp - Choose and lock a rgrp for allocation
723  * @ip: the inode to reserve space for
724  * @rgp: the chosen and locked rgrp
725  *
726  * Try to acquire rgrp in way which avoids contending with others.
727  *
728  * Returns: errno
729  */
730
731 static int get_local_rgrp(struct gfs2_inode *ip)
732 {
733         struct gfs2_sbd *sdp = ip->i_sbd;
734         struct gfs2_rgrpd *rgd, *begin = NULL;
735         struct gfs2_alloc *al = &ip->i_alloc;
736         int flags = LM_FLAG_TRY;
737         int skipped = 0;
738         int loops = 0;
739         int error;
740
741         /* Try recently successful rgrps */
742
743         rgd = recent_rgrp_first(sdp, ip->i_last_rg_alloc);
744
745         while (rgd) {
746                 error = gfs2_glock_nq_init(rgd->rd_gl,
747                                           LM_ST_EXCLUSIVE, LM_FLAG_TRY,
748                                           &al->al_rgd_gh);
749                 switch (error) {
750                 case 0:
751                         if (try_rgrp_fit(rgd, al))
752                                 goto out;
753                         gfs2_glock_dq_uninit(&al->al_rgd_gh);
754                         rgd = recent_rgrp_next(rgd, 1);
755                         break;
756
757                 case GLR_TRYFAILED:
758                         rgd = recent_rgrp_next(rgd, 0);
759                         break;
760
761                 default:
762                         return error;
763                 }
764         }
765
766         /* Go through full list of rgrps */
767
768         begin = rgd = forward_rgrp_get(sdp);
769
770         for (;;) {
771                 error = gfs2_glock_nq_init(rgd->rd_gl,
772                                           LM_ST_EXCLUSIVE, flags,
773                                           &al->al_rgd_gh);
774                 switch (error) {
775                 case 0:
776                         if (try_rgrp_fit(rgd, al))
777                                 goto out;
778                         gfs2_glock_dq_uninit(&al->al_rgd_gh);
779                         break;
780
781                 case GLR_TRYFAILED:
782                         skipped++;
783                         break;
784
785                 default:
786                         return error;
787                 }
788
789                 rgd = gfs2_rgrpd_get_next(rgd);
790                 if (!rgd)
791                         rgd = gfs2_rgrpd_get_first(sdp);
792
793                 if (rgd == begin) {
794                         if (++loops >= 2 || !skipped)
795                                 return -ENOSPC;
796                         flags = 0;
797                 }
798         }
799
800  out:
801         ip->i_last_rg_alloc = rgd->rd_ri.ri_addr;
802
803         if (begin) {
804                 recent_rgrp_add(rgd);
805                 rgd = gfs2_rgrpd_get_next(rgd);
806                 if (!rgd)
807                         rgd = gfs2_rgrpd_get_first(sdp);
808                 forward_rgrp_set(sdp, rgd);
809         }
810
811         return 0;
812 }
813
814 /**
815  * gfs2_inplace_reserve_i - Reserve space in the filesystem
816  * @ip: the inode to reserve space for
817  *
818  * Returns: errno
819  */
820
821 int gfs2_inplace_reserve_i(struct gfs2_inode *ip, char *file, unsigned int line)
822 {
823         struct gfs2_sbd *sdp = ip->i_sbd;
824         struct gfs2_alloc *al = &ip->i_alloc;
825         int error;
826
827         if (gfs2_assert_warn(sdp, al->al_requested))
828                 return -EINVAL;
829
830         error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
831         if (error)
832                 return error;
833
834         error = get_local_rgrp(ip);
835         if (error) {
836                 gfs2_glock_dq_uninit(&al->al_ri_gh);
837                 return error;
838         }
839
840         al->al_file = file;
841         al->al_line = line;
842
843         return 0;
844 }
845
846 /**
847  * gfs2_inplace_release - release an inplace reservation
848  * @ip: the inode the reservation was taken out on
849  *
850  * Release a reservation made by gfs2_inplace_reserve().
851  */
852
853 void gfs2_inplace_release(struct gfs2_inode *ip)
854 {
855         struct gfs2_sbd *sdp = ip->i_sbd;
856         struct gfs2_alloc *al = &ip->i_alloc;
857
858         if (gfs2_assert_warn(sdp, al->al_alloced <= al->al_requested) == -1)
859                 fs_warn(sdp, "al_alloced = %u, al_requested = %u "
860                              "al_file = %s, al_line = %u\n",
861                              al->al_alloced, al->al_requested, al->al_file,
862                              al->al_line);
863
864         al->al_rgd = NULL;
865         gfs2_glock_dq_uninit(&al->al_rgd_gh);
866         gfs2_glock_dq_uninit(&al->al_ri_gh);
867 }
868
869 /**
870  * gfs2_get_block_type - Check a block in a RG is of given type
871  * @rgd: the resource group holding the block
872  * @block: the block number
873  *
874  * Returns: The block type (GFS2_BLKST_*)
875  */
876
877 unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, uint64_t block)
878 {
879         struct gfs2_bitmap *bi = NULL;
880         uint32_t length, rgrp_block, buf_block;
881         unsigned int buf;
882         unsigned char type;
883
884         length = rgd->rd_ri.ri_length;
885         rgrp_block = block - rgd->rd_ri.ri_data0;
886
887         for (buf = 0; buf < length; buf++) {
888                 bi = rgd->rd_bits + buf;
889                 if (rgrp_block < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
890                         break;
891         }
892
893         gfs2_assert(rgd->rd_sbd, buf < length);
894         buf_block = rgrp_block - bi->bi_start * GFS2_NBBY;
895
896         type = gfs2_testbit(rgd,
897                            bi->bi_bh->b_data + bi->bi_offset,
898                            bi->bi_len, buf_block);
899
900         return type;
901 }
902
903 /**
904  * rgblk_search - find a block in @old_state, change allocation
905  *           state to @new_state
906  * @rgd: the resource group descriptor
907  * @goal: the goal block within the RG (start here to search for avail block)
908  * @old_state: GFS2_BLKST_XXX the before-allocation state to find
909  * @new_state: GFS2_BLKST_XXX the after-allocation block state
910  *
911  * Walk rgrp's bitmap to find bits that represent a block in @old_state.
912  * Add the found bitmap buffer to the transaction.
913  * Set the found bits to @new_state to change block's allocation state.
914  *
915  * This function never fails, because we wouldn't call it unless we
916  * know (from reservation results, etc.) that a block is available.
917  *
918  * Scope of @goal and returned block is just within rgrp, not the whole
919  * filesystem.
920  *
921  * Returns:  the block number allocated
922  */
923
924 static uint32_t rgblk_search(struct gfs2_rgrpd *rgd, uint32_t goal,
925                              unsigned char old_state, unsigned char new_state)
926 {
927         struct gfs2_bitmap *bi = NULL;
928         uint32_t length = rgd->rd_ri.ri_length;
929         uint32_t blk = 0;
930         unsigned int buf, x;
931
932         /* Find bitmap block that contains bits for goal block */
933         for (buf = 0; buf < length; buf++) {
934                 bi = rgd->rd_bits + buf;
935                 if (goal < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
936                         break;
937         }
938
939         gfs2_assert(rgd->rd_sbd, buf < length);
940
941         /* Convert scope of "goal" from rgrp-wide to within found bit block */
942         goal -= bi->bi_start * GFS2_NBBY;
943
944         /* Search (up to entire) bitmap in this rgrp for allocatable block.
945            "x <= length", instead of "x < length", because we typically start
946            the search in the middle of a bit block, but if we can't find an
947            allocatable block anywhere else, we want to be able wrap around and
948            search in the first part of our first-searched bit block.  */
949         for (x = 0; x <= length; x++) {
950                 if (bi->bi_clone)
951                         blk = gfs2_bitfit(rgd,
952                                           bi->bi_clone + bi->bi_offset,
953                                           bi->bi_len, goal, old_state);
954                 else
955                         blk = gfs2_bitfit(rgd,
956                                           bi->bi_bh->b_data + bi->bi_offset,
957                                           bi->bi_len, goal, old_state);
958                 if (blk != BFITNOENT)
959                         break;
960
961                 /* Try next bitmap block (wrap back to rgrp header if at end) */
962                 buf = (buf + 1) % length;
963                 bi = rgd->rd_bits + buf;
964                 goal = 0;
965         }
966
967         if (gfs2_assert_withdraw(rgd->rd_sbd, x <= length))
968                 blk = 0;
969
970         gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
971         gfs2_setbit(rgd,
972                     bi->bi_bh->b_data + bi->bi_offset,
973                     bi->bi_len, blk, new_state);
974         if (bi->bi_clone)
975                 gfs2_setbit(rgd,
976                             bi->bi_clone + bi->bi_offset,
977                             bi->bi_len, blk, new_state);
978
979         return bi->bi_start * GFS2_NBBY + blk;
980 }
981
982 /**
983  * rgblk_free - Change alloc state of given block(s)
984  * @sdp: the filesystem
985  * @bstart: the start of a run of blocks to free
986  * @blen: the length of the block run (all must lie within ONE RG!)
987  * @new_state: GFS2_BLKST_XXX the after-allocation block state
988  *
989  * Returns:  Resource group containing the block(s)
990  */
991
992 static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, uint64_t bstart,
993                                      uint32_t blen, unsigned char new_state)
994 {
995         struct gfs2_rgrpd *rgd;
996         struct gfs2_bitmap *bi = NULL;
997         uint32_t length, rgrp_blk, buf_blk;
998         unsigned int buf;
999
1000         rgd = gfs2_blk2rgrpd(sdp, bstart);
1001         if (!rgd) {
1002                 if (gfs2_consist(sdp))
1003                         fs_err(sdp, "block = %llu\n", bstart);
1004                 return NULL;
1005         }
1006
1007         length = rgd->rd_ri.ri_length;
1008
1009         rgrp_blk = bstart - rgd->rd_ri.ri_data0;
1010
1011         while (blen--) {
1012                 for (buf = 0; buf < length; buf++) {
1013                         bi = rgd->rd_bits + buf;
1014                         if (rgrp_blk < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
1015                                 break;
1016                 }
1017
1018                 gfs2_assert(rgd->rd_sbd, buf < length);
1019
1020                 buf_blk = rgrp_blk - bi->bi_start * GFS2_NBBY;
1021                 rgrp_blk++;
1022
1023                 if (!bi->bi_clone) {
1024                         bi->bi_clone = kmalloc(bi->bi_bh->b_size,
1025                                                GFP_KERNEL | __GFP_NOFAIL);
1026                         memcpy(bi->bi_clone + bi->bi_offset,
1027                                bi->bi_bh->b_data + bi->bi_offset,
1028                                bi->bi_len);
1029                 }
1030                 gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
1031                 gfs2_setbit(rgd,
1032                             bi->bi_bh->b_data + bi->bi_offset,
1033                             bi->bi_len, buf_blk, new_state);
1034         }
1035
1036         return rgd;
1037 }
1038
1039 /**
1040  * gfs2_alloc_data - Allocate a data block
1041  * @ip: the inode to allocate the data block for
1042  *
1043  * Returns: the allocated block
1044  */
1045
1046 uint64_t gfs2_alloc_data(struct gfs2_inode *ip)
1047 {
1048         struct gfs2_sbd *sdp = ip->i_sbd;
1049         struct gfs2_alloc *al = &ip->i_alloc;
1050         struct gfs2_rgrpd *rgd = al->al_rgd;
1051         uint32_t goal, blk;
1052         uint64_t block;
1053
1054         if (rgrp_contains_block(&rgd->rd_ri, ip->i_di.di_goal_data))
1055                 goal = ip->i_di.di_goal_data - rgd->rd_ri.ri_data0;
1056         else
1057                 goal = rgd->rd_last_alloc_data;
1058
1059         blk = rgblk_search(rgd, goal,
1060                            GFS2_BLKST_FREE, GFS2_BLKST_USED);
1061         rgd->rd_last_alloc_data = blk;
1062
1063         block = rgd->rd_ri.ri_data0 + blk;
1064         ip->i_di.di_goal_data = block;
1065
1066         gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);
1067         rgd->rd_rg.rg_free--;
1068
1069         gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1070         gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1071
1072         al->al_alloced++;
1073
1074         gfs2_statfs_change(sdp, 0, -1, 0);
1075         gfs2_quota_change(ip, +1, ip->i_di.di_uid, ip->i_di.di_gid);
1076
1077         spin_lock(&sdp->sd_rindex_spin);
1078         rgd->rd_free_clone--;
1079         spin_unlock(&sdp->sd_rindex_spin);
1080
1081         return block;
1082 }
1083
1084 /**
1085  * gfs2_alloc_meta - Allocate a metadata block
1086  * @ip: the inode to allocate the metadata block for
1087  *
1088  * Returns: the allocated block
1089  */
1090
1091 uint64_t gfs2_alloc_meta(struct gfs2_inode *ip)
1092 {
1093         struct gfs2_sbd *sdp = ip->i_sbd;
1094         struct gfs2_alloc *al = &ip->i_alloc;
1095         struct gfs2_rgrpd *rgd = al->al_rgd;
1096         uint32_t goal, blk;
1097         uint64_t block;
1098
1099         if (rgrp_contains_block(&rgd->rd_ri, ip->i_di.di_goal_meta))
1100                 goal = ip->i_di.di_goal_meta - rgd->rd_ri.ri_data0;
1101         else
1102                 goal = rgd->rd_last_alloc_meta;
1103
1104         blk = rgblk_search(rgd, goal,
1105                            GFS2_BLKST_FREE, GFS2_BLKST_USED);
1106         rgd->rd_last_alloc_meta = blk;
1107
1108         block = rgd->rd_ri.ri_data0 + blk;
1109         ip->i_di.di_goal_meta = block;
1110
1111         gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);
1112         rgd->rd_rg.rg_free--;
1113
1114         gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1115         gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1116
1117         al->al_alloced++;
1118
1119         gfs2_statfs_change(sdp, 0, -1, 0);
1120         gfs2_quota_change(ip, +1, ip->i_di.di_uid, ip->i_di.di_gid);
1121         gfs2_trans_add_unrevoke(sdp, block);
1122
1123         spin_lock(&sdp->sd_rindex_spin);
1124         rgd->rd_free_clone--;
1125         spin_unlock(&sdp->sd_rindex_spin);
1126
1127         return block;
1128 }
1129
1130 /**
1131  * gfs2_alloc_di - Allocate a dinode
1132  * @dip: the directory that the inode is going in
1133  *
1134  * Returns: the block allocated
1135  */
1136
1137 uint64_t gfs2_alloc_di(struct gfs2_inode *dip)
1138 {
1139         struct gfs2_sbd *sdp = dip->i_sbd;
1140         struct gfs2_alloc *al = &dip->i_alloc;
1141         struct gfs2_rgrpd *rgd = al->al_rgd;
1142         uint32_t blk;
1143         uint64_t block;
1144
1145         blk = rgblk_search(rgd, rgd->rd_last_alloc_meta,
1146                            GFS2_BLKST_FREE, GFS2_BLKST_DINODE);
1147
1148         rgd->rd_last_alloc_meta = blk;
1149
1150         block = rgd->rd_ri.ri_data0 + blk;
1151
1152         gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);
1153         rgd->rd_rg.rg_free--;
1154         rgd->rd_rg.rg_dinodes++;
1155
1156         gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1157         gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1158
1159         al->al_alloced++;
1160
1161         gfs2_statfs_change(sdp, 0, -1, +1);
1162         gfs2_trans_add_unrevoke(sdp, block);
1163
1164         spin_lock(&sdp->sd_rindex_spin);
1165         rgd->rd_free_clone--;
1166         spin_unlock(&sdp->sd_rindex_spin);
1167
1168         return block;
1169 }
1170
1171 /**
1172  * gfs2_free_data - free a contiguous run of data block(s)
1173  * @ip: the inode these blocks are being freed from
1174  * @bstart: first block of a run of contiguous blocks
1175  * @blen: the length of the block run
1176  *
1177  */
1178
1179 void gfs2_free_data(struct gfs2_inode *ip, uint64_t bstart, uint32_t blen)
1180 {
1181         struct gfs2_sbd *sdp = ip->i_sbd;
1182         struct gfs2_rgrpd *rgd;
1183
1184         rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
1185         if (!rgd)
1186                 return;
1187
1188         rgd->rd_rg.rg_free += blen;
1189
1190         gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1191         gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1192
1193         gfs2_trans_add_rg(rgd);
1194
1195         gfs2_statfs_change(sdp, 0, +blen, 0);
1196         gfs2_quota_change(ip, -(int64_t)blen,
1197                          ip->i_di.di_uid, ip->i_di.di_gid);
1198 }
1199
1200 /**
1201  * gfs2_free_meta - free a contiguous run of data block(s)
1202  * @ip: the inode these blocks are being freed from
1203  * @bstart: first block of a run of contiguous blocks
1204  * @blen: the length of the block run
1205  *
1206  */
1207
1208 void gfs2_free_meta(struct gfs2_inode *ip, uint64_t bstart, uint32_t blen)
1209 {
1210         struct gfs2_sbd *sdp = ip->i_sbd;
1211         struct gfs2_rgrpd *rgd;
1212
1213         rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
1214         if (!rgd)
1215                 return;
1216
1217         rgd->rd_rg.rg_free += blen;
1218
1219         gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1220         gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1221
1222         gfs2_trans_add_rg(rgd);
1223
1224         gfs2_statfs_change(sdp, 0, +blen, 0);
1225         gfs2_quota_change(ip, -(int64_t)blen,
1226                          ip->i_di.di_uid, ip->i_di.di_gid);
1227         gfs2_meta_wipe(ip, bstart, blen);
1228 }
1229
1230 void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, uint64_t blkno)
1231 {
1232         struct gfs2_sbd *sdp = rgd->rd_sbd;
1233         struct gfs2_rgrpd *tmp_rgd;
1234
1235         tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE);
1236         if (!tmp_rgd)
1237                 return;
1238         gfs2_assert_withdraw(sdp, rgd == tmp_rgd);
1239
1240         if (!rgd->rd_rg.rg_dinodes)
1241                 gfs2_consist_rgrpd(rgd);
1242         rgd->rd_rg.rg_dinodes--;
1243         rgd->rd_rg.rg_free++;
1244
1245         gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
1246         gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data);
1247
1248         gfs2_statfs_change(sdp, 0, +1, -1);
1249         gfs2_trans_add_rg(rgd);
1250 }
1251
1252 /**
1253  * gfs2_free_uninit_di - free a dinode block
1254  * @rgd: the resource group that contains the dinode
1255  * @ip: the inode
1256  *
1257  */
1258
1259 void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
1260 {
1261         gfs2_free_uninit_di(rgd, ip->i_num.no_addr);
1262         gfs2_quota_change(ip, -1, ip->i_di.di_uid, ip->i_di.di_gid);
1263         gfs2_meta_wipe(ip, ip->i_num.no_addr, 1);
1264 }
1265
1266 /**
1267  * gfs2_rlist_add - add a RG to a list of RGs
1268  * @sdp: the filesystem
1269  * @rlist: the list of resource groups
1270  * @block: the block
1271  *
1272  * Figure out what RG a block belongs to and add that RG to the list
1273  *
1274  * FIXME: Don't use NOFAIL
1275  *
1276  */
1277
1278 void gfs2_rlist_add(struct gfs2_sbd *sdp, struct gfs2_rgrp_list *rlist,
1279                     uint64_t block)
1280 {
1281         struct gfs2_rgrpd *rgd;
1282         struct gfs2_rgrpd **tmp;
1283         unsigned int new_space;
1284         unsigned int x;
1285
1286         if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
1287                 return;
1288
1289         rgd = gfs2_blk2rgrpd(sdp, block);
1290         if (!rgd) {
1291                 if (gfs2_consist(sdp))
1292                         fs_err(sdp, "block = %llu\n", block);
1293                 return;
1294         }
1295
1296         for (x = 0; x < rlist->rl_rgrps; x++)
1297                 if (rlist->rl_rgd[x] == rgd)
1298                         return;
1299
1300         if (rlist->rl_rgrps == rlist->rl_space) {
1301                 new_space = rlist->rl_space + 10;
1302
1303                 tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
1304                               GFP_KERNEL | __GFP_NOFAIL);
1305
1306                 if (rlist->rl_rgd) {
1307                         memcpy(tmp, rlist->rl_rgd,
1308                                rlist->rl_space * sizeof(struct gfs2_rgrpd *));
1309                         kfree(rlist->rl_rgd);
1310                 }
1311
1312                 rlist->rl_space = new_space;
1313                 rlist->rl_rgd = tmp;
1314         }
1315
1316         rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
1317 }
1318
1319 /**
1320  * gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
1321  *      and initialize an array of glock holders for them
1322  * @rlist: the list of resource groups
1323  * @state: the lock state to acquire the RG lock in
1324  * @flags: the modifier flags for the holder structures
1325  *
1326  * FIXME: Don't use NOFAIL
1327  *
1328  */
1329
1330 void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state,
1331                       int flags)
1332 {
1333         unsigned int x;
1334
1335         rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder),
1336                                 GFP_KERNEL | __GFP_NOFAIL);
1337         for (x = 0; x < rlist->rl_rgrps; x++)
1338                 gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
1339                                 state, flags,
1340                                 &rlist->rl_ghs[x]);
1341 }
1342
1343 /**
1344  * gfs2_rlist_free - free a resource group list
1345  * @list: the list of resource groups
1346  *
1347  */
1348
1349 void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
1350 {
1351         unsigned int x;
1352
1353         kfree(rlist->rl_rgd);
1354
1355         if (rlist->rl_ghs) {
1356                 for (x = 0; x < rlist->rl_rgrps; x++)
1357                         gfs2_holder_uninit(&rlist->rl_ghs[x]);
1358                 kfree(rlist->rl_ghs);
1359         }
1360 }
1361