Lines Matching defs:rgd
40 struct gfs2_rgrpd *rgd;
47 return rbm->rgd->rd_bits + rbm->bii;
52 BUG_ON(rbm->offset >= rbm->rgd->rd_data);
53 return rbm->rgd->rd_data0 + (rbm_bi(rbm)->bi_start * GFS2_NBBY) +
109 struct gfs2_sbd *sdp = rbm->rgd->rd_sbd;
114 (unsigned long long)rbm->rgd->rd_addr, bi->bi_start,
120 gfs2_consist_rgrpd(rbm->rgd);
265 * gfs2_rbm_from_block - Set the rbm based upon rgd and block number
266 * @rbm: The rbm with rgd already set correctly
279 if (!rgrp_contains_block(rbm->rgd, block))
282 rbm->offset = block - rbm->rgd->rd_data0;
290 rbm->bii = rbm->offset / rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
291 rbm->offset -= rbm->bii * rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
297 * @rbm: The rbm with rgd already set correctly
308 struct gfs2_rgrpd *rgd = rbm->rgd;
309 struct gfs2_bitmap *bi = rgd->rd_bits + rbm->bii;
319 if (bi == rgd->rd_bits + rgd->rd_length)
323 rbm->bii = bi - rgd->rd_bits;
427 * @rgd: the resource group descriptor
435 static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
461 * @rgd: the rgrp
465 void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
467 struct gfs2_sbd *sdp = rgd->rd_sbd;
469 u32 length = rgd->rd_length;
477 bi = rgd->rd_bits + buf;
479 count[x] += gfs2_bitcount(rgd,
485 if (count[0] != rgd->rd_free) {
487 count[0], rgd->rd_free);
488 gfs2_consist_rgrpd(rgd);
492 tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
496 gfs2_consist_rgrpd(rgd);
500 if (count[2] + count[3] != rgd->rd_dinodes) {
502 count[2] + count[3], rgd->rd_dinodes);
503 gfs2_consist_rgrpd(rgd);
565 struct gfs2_rgrpd *rgd;
569 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
572 return rgd;
577 * @rgd: the resource group descriptor
582 struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
584 struct gfs2_sbd *sdp = rgd->rd_sbd;
588 n = rb_next(&rgd->rd_node);
592 if (unlikely(&rgd->rd_node == n)) {
596 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
598 return rgd;
608 void gfs2_free_clones(struct gfs2_rgrpd *rgd)
612 for (x = 0; x < rgd->rd_length; x++) {
613 struct gfs2_bitmap *bi = rgd->rd_bits + x;
632 * __rs_deltree - remove a multi-block reservation from the rgd tree
638 struct gfs2_rgrpd *rgd;
643 rgd = rs->rs_rgd;
645 rb_erase(&rs->rs_node, &rgd->rd_rstree);
657 rgd->rd_extfail_pt += rs->rs_requested;
663 * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
669 struct gfs2_rgrpd *rgd;
671 rgd = rs->rs_rgd;
672 if (rgd) {
673 spin_lock(&rgd->rd_rsspin);
676 spin_unlock(&rgd->rd_rsspin);
697 * @rgd: the rgrp that needs its space back
703 static void return_all_reservations(struct gfs2_rgrpd *rgd)
708 spin_lock(&rgd->rd_rsspin);
709 while ((n = rb_first(&rgd->rd_rstree))) {
713 spin_unlock(&rgd->rd_rsspin);
719 struct gfs2_rgrpd *rgd;
723 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
724 gl = rgd->rd_gl;
733 gfs2_rgrp_brelse(rgd);
734 glock_clear_object(gl, rgd);
738 gfs2_free_clones(rgd);
739 return_all_reservations(rgd);
740 kfree(rgd->rd_bits);
741 rgd->rd_bits = NULL;
742 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
748 * @rgd: The resource group descriptor
755 static int compute_bitstructs(struct gfs2_rgrpd *rgd)
757 struct gfs2_sbd *sdp = rgd->rd_sbd;
759 u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
766 rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
767 if (!rgd->rd_bits)
770 bytes_left = rgd->rd_bitbytes;
773 bi = rgd->rd_bits + x;
794 bi->bi_start = rgd->rd_bitbytes - bytes_left;
802 bi->bi_start = rgd->rd_bitbytes - bytes_left;
811 gfs2_consist_rgrpd(rgd);
814 bi = rgd->rd_bits + (length - 1);
815 if ((bi->bi_start + bi->bi_bytes) * GFS2_NBBY != rgd->rd_data) {
823 (unsigned long long)rgd->rd_addr,
824 rgd->rd_length,
825 (unsigned long long)rgd->rd_data0,
826 rgd->rd_data,
827 rgd->rd_bitbytes,
829 gfs2_consist_rgrpd(rgd);
863 static int rgd_insert(struct gfs2_rgrpd *rgd)
865 struct gfs2_sbd *sdp = rgd->rd_sbd;
874 if (rgd->rd_addr < cur->rd_addr)
876 else if (rgd->rd_addr > cur->rd_addr)
882 rb_link_node(&rgd->rd_node, parent, newn);
883 rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
901 struct gfs2_rgrpd *rgd;
912 rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
914 if (!rgd)
917 rgd->rd_sbd = sdp;
918 rgd->rd_addr = be64_to_cpu(buf.ri_addr);
919 rgd->rd_length = be32_to_cpu(buf.ri_length);
920 rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
921 rgd->rd_data = be32_to_cpu(buf.ri_data);
922 rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
923 spin_lock_init(&rgd->rd_rsspin);
924 mutex_init(&rgd->rd_mutex);
926 error = gfs2_glock_get(sdp, rgd->rd_addr,
927 &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
931 error = compute_bitstructs(rgd);
935 rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lksb.sb_lvbptr;
936 rgd->rd_flags &= ~GFS2_RDF_PREFERRED;
937 if (rgd->rd_data > sdp->sd_max_rg_data)
938 sdp->sd_max_rg_data = rgd->rd_data;
940 error = rgd_insert(rgd);
943 glock_set_object(rgd->rd_gl, rgd);
949 gfs2_glock_put(rgd->rd_gl);
952 kfree(rgd->rd_bits);
953 rgd->rd_bits = NULL;
954 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
968 struct gfs2_rgrpd *rgd, *first;
973 rgd = gfs2_rgrpd_get_first(sdp);
975 rgd = gfs2_rgrpd_get_next(rgd);
976 first = rgd;
979 rgd->rd_flags |= GFS2_RDF_PREFERRED;
981 rgd = gfs2_rgrpd_get_next(rgd);
982 if (!rgd || rgd == first)
985 } while (rgd && rgd != first);
1059 static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
1066 rgd->rd_flags &= GFS2_RDF_MASK;
1067 rgd->rd_flags |= rg_flags;
1068 rgd->rd_free = be32_to_cpu(str->rg_free);
1069 rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
1070 rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
1086 static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
1088 struct gfs2_rgrpd *next = gfs2_rgrpd_get_next(rgd);
1092 str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
1093 str->rg_free = cpu_to_be32(rgd->rd_free);
1094 str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
1097 else if (next->rd_addr > rgd->rd_addr)
1098 str->rg_skip = cpu_to_be32(next->rd_addr - rgd->rd_addr);
1099 str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
1100 str->rg_data0 = cpu_to_be64(rgd->rd_data0);
1101 str->rg_data = cpu_to_be32(rgd->rd_data);
1102 str->rg_bitbytes = cpu_to_be32(rgd->rd_bitbytes);
1108 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, buf);
1111 static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
1113 struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
1114 struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
1115 struct gfs2_sbd *sdp = rgd->rd_sbd;
1119 fs_warn(sdp, "GFS2: rgd: %llu lvb flag mismatch %u/%u",
1120 (unsigned long long)rgd->rd_addr,
1125 fs_warn(sdp, "GFS2: rgd: %llu lvb free mismatch %u/%u",
1126 (unsigned long long)rgd->rd_addr,
1131 fs_warn(sdp, "GFS2: rgd: %llu lvb dinode mismatch %u/%u",
1132 (unsigned long long)rgd->rd_addr,
1138 fs_warn(sdp, "GFS2: rgd: %llu lvb igen mismatch %llu/%llu",
1139 (unsigned long long)rgd->rd_addr,
1147 static u32 count_unlinked(struct gfs2_rgrpd *rgd)
1150 const u32 length = rgd->rd_length;
1154 for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
1171 static void rgrp_set_bitmap_flags(struct gfs2_rgrpd *rgd)
1176 if (rgd->rd_free) {
1177 for (x = 0; x < rgd->rd_length; x++) {
1178 bi = rgd->rd_bits + x;
1182 for (x = 0; x < rgd->rd_length; x++) {
1183 bi = rgd->rd_bits + x;
1201 struct gfs2_rgrpd *rgd = gl->gl_object;
1202 struct gfs2_sbd *sdp = rgd->rd_sbd;
1203 unsigned int length = rgd->rd_length;
1208 if (rgd->rd_bits[0].bi_bh != NULL)
1212 bi = rgd->rd_bits + x;
1213 error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, 0, &bi->bi_bh);
1219 bi = rgd->rd_bits + y;
1230 gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
1231 rgrp_set_bitmap_flags(rgd);
1232 rgd->rd_flags |= GFS2_RDF_CHECK;
1233 rgd->rd_free_clone = rgd->rd_free;
1234 GLOCK_BUG_ON(rgd->rd_gl, rgd->rd_reserved);
1236 rgd->rd_extfail_pt = rgd->rd_free;
1237 if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
1238 rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
1239 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
1240 rgd->rd_bits[0].bi_bh->b_data);
1242 if (!gfs2_rgrp_lvb_valid(rgd)){
1243 gfs2_consist_rgrpd(rgd);
1247 if (rgd->rd_rgl->rl_unlinked == 0)
1248 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1254 bi = rgd->rd_bits + x;
1262 static int update_rgrp_lvb(struct gfs2_rgrpd *rgd, struct gfs2_holder *gh)
1269 if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
1272 rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
1274 rgd->rd_flags &= GFS2_RDF_MASK;
1275 rgd->rd_flags |= (rl_flags | GFS2_RDF_CHECK);
1276 if (rgd->rd_rgl->rl_unlinked == 0)
1277 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1278 rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
1279 rgrp_set_bitmap_flags(rgd);
1280 rgd->rd_free_clone = rgd->rd_free;
1281 GLOCK_BUG_ON(rgd->rd_gl, rgd->rd_reserved);
1283 rgd->rd_extfail_pt = rgd->rd_free;
1284 rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
1285 rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
1291 * @rgd: The resource group
1295 void gfs2_rgrp_brelse(struct gfs2_rgrpd *rgd)
1297 int x, length = rgd->rd_length;
1300 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1306 set_bit(GLF_INSTANTIATE_NEEDED, &rgd->rd_gl->gl_flags);
1390 struct gfs2_rgrpd *rgd;
1425 rgd = gfs2_blk2rgrpd(sdp, start, 0);
1434 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
1439 if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
1441 for (x = 0; x < rgd->rd_length; x++) {
1442 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1443 rgrp_lock_local(rgd);
1445 rgd->rd_data0, NULL, bi, minlen,
1447 rgrp_unlock_local(rgd);
1458 bh = rgd->rd_bits[0].bi_bh;
1459 rgrp_lock_local(rgd);
1460 rgd->rd_flags |= GFS2_RGF_TRIMMED;
1461 gfs2_trans_add_meta(rgd->rd_gl, bh);
1462 gfs2_rgrp_out(rgd, bh->b_data);
1463 rgrp_unlock_local(rgd);
1469 if (rgd == rgd_end)
1472 rgd = gfs2_rgrpd_get_next(rgd);
1493 struct gfs2_rgrpd *rgd = rs->rs_rgd;
1497 spin_lock(&rgd->rd_rsspin);
1498 newn = &rgd->rd_rstree.rb_node;
1510 spin_unlock(&rgd->rd_rsspin);
1517 rb_insert_color(&rs->rs_node, &rgd->rd_rstree);
1520 rgd->rd_requested += rs->rs_requested; /* blocks requested */
1521 spin_unlock(&rgd->rd_rsspin);
1527 * @rgd: the resource group
1538 static inline u32 rgd_free(struct gfs2_rgrpd *rgd, struct gfs2_blkreserv *rs)
1542 if (WARN_ON_ONCE(rgd->rd_requested < rs->rs_requested))
1544 tot_reserved = rgd->rd_requested - rs->rs_requested;
1546 if (rgd->rd_free_clone < tot_reserved)
1549 tot_free = rgd->rd_free_clone - tot_reserved;
1556 * @rgd: the resource group descriptor
1562 static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
1565 struct gfs2_rbm rbm = { .rgd = rgd, };
1573 spin_lock(&rgd->rd_rsspin);
1574 free_blocks = rgd_free(rgd, rs);
1575 if (rgd->rd_free_clone < rgd->rd_requested)
1577 blocks_available = rgd->rd_free_clone - rgd->rd_reserved;
1578 if (rgd == rs->rs_rgd)
1580 spin_unlock(&rgd->rd_rsspin);
1592 if (rgrp_contains_block(rgd, ip->i_goal))
1595 goal = rgd->rd_last_alloc + rgd->rd_data0;
1606 if (goal == rgd->rd_last_alloc + rgd->rd_data0)
1607 rgd->rd_last_alloc = 0;
1613 * @rgd: The resource group
1624 static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
1632 spin_lock(&rgd->rd_rsspin);
1633 n = rgd->rd_rstree.rb_node;
1655 spin_unlock(&rgd->rd_rsspin);
1698 nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, rs);
1749 struct gfs2_extent maxext = { .rbm.rgd = rbm->rgd, };
1795 if (rbm->bii == rbm->rgd->rd_length)
1818 *minext < rbm->rgd->rd_extfail_pt)
1819 rbm->rgd->rd_extfail_pt = *minext - 1;
1834 * @rgd: The rgrp
1842 static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
1845 struct gfs2_sbd *sdp = rgd->rd_sbd;
1850 struct gfs2_rbm rbm = { .rgd = rgd, .bii = 0, .offset = 0 };
1892 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1898 * @rgd: The rgrp in question
1923 static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
1925 const struct gfs2_glock *gl = rgd->rd_gl;
1998 struct gfs2_rgrpd *rgd = *pos;
1999 struct gfs2_sbd *sdp = rgd->rd_sbd;
2001 rgd = gfs2_rgrpd_get_next(rgd);
2002 if (rgd == NULL)
2003 rgd = gfs2_rgrpd_get_first(sdp);
2004 *pos = rgd;
2005 if (rgd != begin) /* If we didn't wrap */
2012 * @rgd: The rgrp
2017 static inline int fast_to_acquire(struct gfs2_rgrpd *rgd)
2019 struct gfs2_glock *gl = rgd->rd_gl;
2025 if (rgd->rd_flags & GFS2_RDF_PREFERRED)
2078 struct gfs2_rgrpd *rgd;
2136 rgd = rs->rs_rgd;
2137 spin_lock(&rgd->rd_rsspin);
2138 free_blocks = rgd_free(rgd, rs);
2139 blocks_available = rgd->rd_free_clone - rgd->rd_reserved;
2141 spin_unlock(&rgd->rd_rsspin);
2147 rgd->rd_reserved += rs->rs_reserved;
2148 spin_unlock(&rgd->rd_rsspin);
2208 struct gfs2_rgrpd *rgd = rs->rs_rgd;
2210 spin_lock(&rgd->rd_rsspin);
2211 GLOCK_BUG_ON(rgd->rd_gl, rgd->rd_reserved < rs->rs_reserved);
2212 rgd->rd_reserved -= rs->rs_reserved;
2213 spin_unlock(&rgd->rd_rsspin);
2232 struct gfs2_rbm pos = { .rgd = rbm->rgd, };
2239 gfs2_trans_add_meta(rbm->rgd->rd_gl, rbm_bi(rbm)->bi_bh);
2246 gfs2_trans_add_meta(pos.rgd->rd_gl, rbm_bi(&pos)->bi_bh);
2256 * @rgd: the resource group the blocks are in
2262 static void rgblk_free(struct gfs2_sbd *sdp, struct gfs2_rgrpd *rgd,
2268 rbm.rgd = rgd;
2281 gfs2_trans_add_meta(rbm.rgd->rd_gl, bi->bi_bh);
2292 * @rgd: The rgrp in question
2297 void gfs2_rgrp_dump(struct seq_file *seq, struct gfs2_rgrpd *rgd,
2303 spin_lock(&rgd->rd_rsspin);
2306 (unsigned long long)rgd->rd_addr, rgd->rd_flags,
2307 rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
2308 rgd->rd_requested, rgd->rd_reserved, rgd->rd_extfail_pt);
2309 if (rgd->rd_sbd->sd_args.ar_rgrplvb && rgd->rd_rgl) {
2310 struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
2317 for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
2321 spin_unlock(&rgd->rd_rsspin);
2324 static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
2326 struct gfs2_sbd *sdp = rgd->rd_sbd;
2330 (unsigned long long)rgd->rd_addr);
2333 gfs2_rgrp_dump(NULL, rgd, fs_id_buf);
2334 rgd->rd_flags |= GFS2_RDF_ERROR;
2352 struct gfs2_rgrpd *rgd = rbm->rgd;
2365 rgd->rd_requested -= rlen;
2367 if (rs->rs_start < rgd->rd_data0 + rgd->rd_data &&
2397 if (!dinode && rgrp_contains_block(rbm->rgd, ip->i_goal))
2400 goal = rbm->rgd->rd_last_alloc + rbm->rgd->rd_data0;
2423 struct gfs2_rbm rbm = { .rgd = ip->i_res.rs_rgd, };
2430 rgrp_lock_local(rbm.rgd);
2444 test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags),
2445 rbm.rgd->rd_extfail_pt);
2451 rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
2464 spin_lock(&rbm.rgd->rd_rsspin);
2466 if (rbm.rgd->rd_free < *nblocks || rbm.rgd->rd_reserved < *nblocks) {
2468 spin_unlock(&rbm.rgd->rd_rsspin);
2471 GLOCK_BUG_ON(rbm.rgd->rd_gl, rbm.rgd->rd_reserved < *nblocks);
2472 GLOCK_BUG_ON(rbm.rgd->rd_gl, rbm.rgd->rd_free_clone < *nblocks);
2473 GLOCK_BUG_ON(rbm.rgd->rd_gl, rbm.rgd->rd_free < *nblocks);
2474 rbm.rgd->rd_reserved -= *nblocks;
2475 rbm.rgd->rd_free_clone -= *nblocks;
2476 rbm.rgd->rd_free -= *nblocks;
2477 spin_unlock(&rbm.rgd->rd_rsspin);
2481 rbm.rgd->rd_dinodes++;
2482 generation = rbm.rgd->rd_igeneration++;
2484 generation = rbm.rgd->rd_igeneration++;
2488 gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh);
2489 gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
2490 rgrp_unlock_local(rbm.rgd);
2498 trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
2504 rgrp_unlock_local(rbm.rgd);
2505 gfs2_rgrp_error(rbm.rgd);
2512 * @rgd: the resource group the blocks are in
2519 void __gfs2_free_blocks(struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
2524 rgrp_lock_local(rgd);
2525 rgblk_free(sdp, rgd, bstart, blen, GFS2_BLKST_FREE);
2526 trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
2527 rgd->rd_free += blen;
2528 rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
2529 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2530 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2531 rgrp_unlock_local(rgd);
2541 * @rgd: the resource group the blocks are in
2547 void gfs2_free_meta(struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
2552 __gfs2_free_blocks(ip, rgd, bstart, blen, 1);
2561 struct gfs2_rgrpd *rgd;
2564 rgd = gfs2_blk2rgrpd(sdp, blkno, true);
2565 if (!rgd)
2567 rgrp_lock_local(rgd);
2568 rgblk_free(sdp, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
2569 trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
2570 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2571 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2572 be32_add_cpu(&rgd->rd_rgl->rl_unlinked, 1);
2573 rgrp_unlock_local(rgd);
2576 void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
2578 struct gfs2_sbd *sdp = rgd->rd_sbd;
2580 rgrp_lock_local(rgd);
2581 rgblk_free(sdp, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
2582 if (!rgd->rd_dinodes)
2583 gfs2_consist_rgrpd(rgd);
2584 rgd->rd_dinodes--;
2585 rgd->rd_free++;
2587 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2588 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2589 be32_add_cpu(&rgd->rd_rgl->rl_unlinked, -1);
2590 rgrp_unlock_local(rgd);
2593 trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
2615 struct gfs2_rgrpd *rgd;
2620 rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
2621 if (!rgd)
2624 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
2628 rbm.rgd = rgd;
2664 struct gfs2_rgrpd *rgd;
2677 rgd = rlist->rl_rgd[rlist->rl_rgrps - 1];
2678 if (rgrp_contains_block(rgd, block))
2680 rgd = gfs2_blk2rgrpd(sdp, block, 1);
2682 rgd = ip->i_res.rs_rgd;
2683 if (!rgd || !rgrp_contains_block(rgd, block))
2684 rgd = gfs2_blk2rgrpd(sdp, block, 1);
2687 if (!rgd) {
2694 if (rlist->rl_rgd[x] == rgd) {
2717 rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
2764 void rgrp_lock_local(struct gfs2_rgrpd *rgd)
2766 mutex_lock(&rgd->rd_mutex);
2769 void rgrp_unlock_local(struct gfs2_rgrpd *rgd)
2771 mutex_unlock(&rgd->rd_mutex);