Lines Matching defs:rgd
91 struct gfs2_sbd *sdp = rbm->rgd->rd_sbd;
96 (unsigned long long)rbm->rgd->rd_addr, bi->bi_start,
102 gfs2_consist_rgrpd(rbm->rgd);
249 * gfs2_rbm_from_block - Set the rbm based upon rgd and block number
250 * @rbm: The rbm with rgd already set correctly
263 if (!rgrp_contains_block(rbm->rgd, block))
266 rbm->offset = block - rbm->rgd->rd_data0;
274 rbm->bii = rbm->offset / rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
275 rbm->offset -= rbm->bii * rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
281 * @rbm: The rbm with rgd already set correctly
297 if (rbm->bii == rbm->rgd->rd_length - 1) /* at the last bitmap */
401 * @rgd: the resource group descriptor
409 static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
435 * @rgd: the rgrp
439 void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
441 struct gfs2_sbd *sdp = rgd->rd_sbd;
443 u32 length = rgd->rd_length;
451 bi = rgd->rd_bits + buf;
453 count[x] += gfs2_bitcount(rgd,
459 if (count[0] != rgd->rd_free) {
461 count[0], rgd->rd_free);
462 gfs2_consist_rgrpd(rgd);
466 tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
470 gfs2_consist_rgrpd(rgd);
474 if (count[2] + count[3] != rgd->rd_dinodes) {
476 count[2] + count[3], rgd->rd_dinodes);
477 gfs2_consist_rgrpd(rgd);
539 struct gfs2_rgrpd *rgd;
543 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
546 return rgd;
551 * @rgd: the resource group descriptor
556 struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
558 struct gfs2_sbd *sdp = rgd->rd_sbd;
562 n = rb_next(&rgd->rd_node);
566 if (unlikely(&rgd->rd_node == n)) {
570 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
572 return rgd;
582 void gfs2_free_clones(struct gfs2_rgrpd *rgd)
586 for (x = 0; x < rgd->rd_length; x++) {
587 struct gfs2_bitmap *bi = rgd->rd_bits + x;
605 * __rs_deltree - remove a multi-block reservation from the rgd tree
611 struct gfs2_rgrpd *rgd;
616 rgd = rs->rs_rbm.rgd;
618 rb_erase(&rs->rs_node, &rgd->rd_rstree);
624 struct gfs2_rbm last_rbm = { .rgd = rs->rs_rbm.rgd, };
628 BUG_ON(rs->rs_rbm.rgd->rd_reserved < rs->rs_free);
629 rs->rs_rbm.rgd->rd_reserved -= rs->rs_free;
634 rgd->rd_extfail_pt += rs->rs_free;
647 * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
653 struct gfs2_rgrpd *rgd;
655 rgd = rs->rs_rbm.rgd;
656 if (rgd) {
657 spin_lock(&rgd->rd_rsspin);
660 spin_unlock(&rgd->rd_rsspin);
681 * @rgd: the rgrp that needs its space back
687 static void return_all_reservations(struct gfs2_rgrpd *rgd)
692 spin_lock(&rgd->rd_rsspin);
693 while ((n = rb_first(&rgd->rd_rstree))) {
697 spin_unlock(&rgd->rd_rsspin);
703 struct gfs2_rgrpd *rgd;
707 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
708 gl = rgd->rd_gl;
717 gfs2_rgrp_brelse(rgd);
718 glock_clear_object(gl, rgd);
722 gfs2_free_clones(rgd);
723 return_all_reservations(rgd);
724 kfree(rgd->rd_bits);
725 rgd->rd_bits = NULL;
726 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
732 * @rgd: The resource group descriptor
739 static int compute_bitstructs(struct gfs2_rgrpd *rgd)
741 struct gfs2_sbd *sdp = rgd->rd_sbd;
743 u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
750 rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
751 if (!rgd->rd_bits)
754 bytes_left = rgd->rd_bitbytes;
757 bi = rgd->rd_bits + x;
778 bi->bi_start = rgd->rd_bitbytes - bytes_left;
786 bi->bi_start = rgd->rd_bitbytes - bytes_left;
795 gfs2_consist_rgrpd(rgd);
798 bi = rgd->rd_bits + (length - 1);
799 if ((bi->bi_start + bi->bi_bytes) * GFS2_NBBY != rgd->rd_data) {
807 (unsigned long long)rgd->rd_addr,
808 rgd->rd_length,
809 (unsigned long long)rgd->rd_data0,
810 rgd->rd_data,
811 rgd->rd_bitbytes,
813 gfs2_consist_rgrpd(rgd);
847 static int rgd_insert(struct gfs2_rgrpd *rgd)
849 struct gfs2_sbd *sdp = rgd->rd_sbd;
858 if (rgd->rd_addr < cur->rd_addr)
860 else if (rgd->rd_addr > cur->rd_addr)
866 rb_link_node(&rgd->rd_node, parent, newn);
867 rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
885 struct gfs2_rgrpd *rgd;
896 rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
898 if (!rgd)
901 rgd->rd_sbd = sdp;
902 rgd->rd_addr = be64_to_cpu(buf.ri_addr);
903 rgd->rd_length = be32_to_cpu(buf.ri_length);
904 rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
905 rgd->rd_data = be32_to_cpu(buf.ri_data);
906 rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
907 spin_lock_init(&rgd->rd_rsspin);
909 error = gfs2_glock_get(sdp, rgd->rd_addr,
910 &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
914 error = compute_bitstructs(rgd);
918 rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lksb.sb_lvbptr;
919 rgd->rd_flags &= ~(GFS2_RDF_UPTODATE | GFS2_RDF_PREFERRED);
920 if (rgd->rd_data > sdp->sd_max_rg_data)
921 sdp->sd_max_rg_data = rgd->rd_data;
923 error = rgd_insert(rgd);
926 glock_set_object(rgd->rd_gl, rgd);
932 gfs2_glock_put(rgd->rd_gl);
935 kfree(rgd->rd_bits);
936 rgd->rd_bits = NULL;
937 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
951 struct gfs2_rgrpd *rgd, *first;
956 rgd = gfs2_rgrpd_get_first(sdp);
958 rgd = gfs2_rgrpd_get_next(rgd);
959 first = rgd;
962 rgd->rd_flags |= GFS2_RDF_PREFERRED;
964 rgd = gfs2_rgrpd_get_next(rgd);
965 if (!rgd || rgd == first)
968 } while (rgd && rgd != first);
1042 static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
1049 rgd->rd_flags &= GFS2_RDF_MASK;
1050 rgd->rd_flags |= rg_flags;
1051 rgd->rd_free = be32_to_cpu(str->rg_free);
1052 rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
1053 rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
1069 static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
1071 struct gfs2_rgrpd *next = gfs2_rgrpd_get_next(rgd);
1075 str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
1076 str->rg_free = cpu_to_be32(rgd->rd_free);
1077 str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
1080 else if (next->rd_addr > rgd->rd_addr)
1081 str->rg_skip = cpu_to_be32(next->rd_addr - rgd->rd_addr);
1082 str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
1083 str->rg_data0 = cpu_to_be64(rgd->rd_data0);
1084 str->rg_data = cpu_to_be32(rgd->rd_data);
1085 str->rg_bitbytes = cpu_to_be32(rgd->rd_bitbytes);
1091 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, buf);
1094 static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
1096 struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
1097 struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
1098 struct gfs2_sbd *sdp = rgd->rd_sbd;
1102 fs_warn(sdp, "GFS2: rgd: %llu lvb flag mismatch %u/%u",
1103 (unsigned long long)rgd->rd_addr,
1108 fs_warn(sdp, "GFS2: rgd: %llu lvb free mismatch %u/%u",
1109 (unsigned long long)rgd->rd_addr,
1114 fs_warn(sdp, "GFS2: rgd: %llu lvb dinode mismatch %u/%u",
1115 (unsigned long long)rgd->rd_addr,
1121 fs_warn(sdp, "GFS2: rgd: %llu lvb igen mismatch %llu/%llu",
1122 (unsigned long long)rgd->rd_addr,
1130 static u32 count_unlinked(struct gfs2_rgrpd *rgd)
1133 const u32 length = rgd->rd_length;
1137 for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
1157 * @rgd: the struct gfs2_rgrpd describing the RG to read in
1165 static int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
1167 struct gfs2_sbd *sdp = rgd->rd_sbd;
1168 struct gfs2_glock *gl = rgd->rd_gl;
1169 unsigned int length = rgd->rd_length;
1174 if (rgd->rd_bits[0].bi_bh != NULL)
1178 bi = rgd->rd_bits + x;
1179 error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, 0, &bi->bi_bh);
1185 bi = rgd->rd_bits + y;
1196 if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
1198 clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
1199 gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
1200 rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
1201 rgd->rd_free_clone = rgd->rd_free;
1203 rgd->rd_extfail_pt = rgd->rd_free;
1205 if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
1206 rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
1207 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
1208 rgd->rd_bits[0].bi_bh->b_data);
1211 if (!gfs2_rgrp_lvb_valid(rgd)){
1212 gfs2_consist_rgrpd(rgd);
1216 if (rgd->rd_rgl->rl_unlinked == 0)
1217 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1223 bi = rgd->rd_bits + x;
1232 static int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
1236 if (rgd->rd_flags & GFS2_RDF_UPTODATE)
1239 if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
1240 return gfs2_rgrp_bh_get(rgd);
1242 rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
1244 rgd->rd_flags &= GFS2_RDF_MASK;
1245 rgd->rd_flags |= (rl_flags | GFS2_RDF_CHECK);
1246 if (rgd->rd_rgl->rl_unlinked == 0)
1247 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1248 rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
1249 rgd->rd_free_clone = rgd->rd_free;
1251 rgd->rd_extfail_pt = rgd->rd_free;
1252 rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
1253 rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
1259 struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1260 struct gfs2_sbd *sdp = rgd->rd_sbd;
1264 return gfs2_rgrp_bh_get(rgd);
1269 * @rgd: The resource group
1273 void gfs2_rgrp_brelse(struct gfs2_rgrpd *rgd)
1275 int x, length = rgd->rd_length;
1278 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1367 struct gfs2_rgrpd *rgd;
1403 rgd = gfs2_blk2rgrpd(sdp, start, 0);
1412 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
1416 if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
1418 for (x = 0; x < rgd->rd_length; x++) {
1419 struct gfs2_bitmap *bi = rgd->rd_bits + x;
1421 rgd->rd_data0, NULL, bi, minlen,
1433 bh = rgd->rd_bits[0].bi_bh;
1434 rgd->rd_flags |= GFS2_RGF_TRIMMED;
1435 gfs2_trans_add_meta(rgd->rd_gl, bh);
1436 gfs2_rgrp_out(rgd, bh->b_data);
1442 if (rgd == rgd_end)
1445 rgd = gfs2_rgrpd_get_next(rgd);
1466 struct gfs2_rgrpd *rgd = rs->rs_rbm.rgd;
1471 spin_lock(&rgd->rd_rsspin);
1472 newn = &rgd->rd_rstree.rb_node;
1484 spin_unlock(&rgd->rd_rsspin);
1491 rb_insert_color(&rs->rs_node, &rgd->rd_rstree);
1494 rgd->rd_reserved += rs->rs_free; /* blocks reserved */
1495 spin_unlock(&rgd->rd_rsspin);
1501 * @rgd: the resource group
1511 static inline u32 rgd_free(struct gfs2_rgrpd *rgd, struct gfs2_blkreserv *rs)
1515 if (WARN_ON_ONCE(rgd->rd_reserved < rs->rs_free))
1517 tot_reserved = rgd->rd_reserved - rs->rs_free;
1519 if (rgd->rd_free_clone < tot_reserved)
1522 tot_free = rgd->rd_free_clone - tot_reserved;
1529 * @rgd: the resource group descriptor
1535 static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
1538 struct gfs2_rbm rbm = { .rgd = rgd, };
1542 u32 free_blocks = rgd_free(rgd, rs);
1552 if ((rgd->rd_free_clone < rgd->rd_reserved) || (free_blocks < extlen))
1556 if (rgrp_contains_block(rgd, ip->i_goal))
1559 goal = rgd->rd_last_alloc + rgd->rd_data0;
1570 if (goal == rgd->rd_last_alloc + rgd->rd_data0)
1571 rgd->rd_last_alloc = 0;
1577 * @rgd: The resource group
1588 static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
1596 spin_lock(&rgd->rd_rsspin);
1597 n = rgd->rd_rstree.rb_node;
1619 spin_unlock(&rgd->rd_rsspin);
1663 nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, ip);
1711 struct gfs2_extent maxext = { .rbm.rgd = rbm->rgd, };
1757 if (rbm->bii == rbm->rgd->rd_length)
1780 *minext < rbm->rgd->rd_extfail_pt)
1781 rbm->rgd->rd_extfail_pt = *minext - 1;
1796 * @rgd: The rgrp
1804 static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
1807 struct gfs2_sbd *sdp = rgd->rd_sbd;
1812 struct gfs2_rbm rbm = { .rgd = rgd, .bii = 0, .offset = 0 };
1854 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1860 * @rgd: The rgrp in question
1885 static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
1887 const struct gfs2_glock *gl = rgd->rd_gl;
1944 rs->rs_rbm.rgd->rd_gl->gl_dstamp));
1960 struct gfs2_rgrpd *rgd = *pos;
1961 struct gfs2_sbd *sdp = rgd->rd_sbd;
1963 rgd = gfs2_rgrpd_get_next(rgd);
1964 if (rgd == NULL)
1965 rgd = gfs2_rgrpd_get_first(sdp);
1966 *pos = rgd;
1967 if (rgd != begin) /* If we didn't wrap */
1978 static inline int fast_to_acquire(struct gfs2_rgrpd *rgd)
1980 struct gfs2_glock *gl = rgd->rd_gl;
1986 if (rgd->rd_flags & GFS2_RDF_PREFERRED)
2022 begin = rs->rs_rbm.rgd;
2023 } else if (rs->rs_rbm.rgd &&
2024 rgrp_contains_block(rs->rs_rbm.rgd, ip->i_goal)) {
2025 begin = rs->rs_rbm.rgd;
2028 rs->rs_rbm.rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
2032 if (rs->rs_rbm.rgd == NULL)
2038 if (!gfs2_glock_is_locked_by_me(rs->rs_rbm.rgd->rd_gl)) {
2044 !fast_to_acquire(rs->rs_rbm.rgd))
2048 gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
2051 error = gfs2_glock_nq_init(rs->rs_rbm.rgd->rd_gl,
2057 gfs2_rgrp_congested(rs->rs_rbm.rgd, loops))
2060 error = update_rgrp_lvb(rs->rs_rbm.rgd);
2069 if ((rs->rs_rbm.rgd->rd_flags & (GFS2_RGF_NOALLOC |
2071 (loops == 0 && ap->target > rs->rs_rbm.rgd->rd_extfail_pt))
2075 gfs2_rgrp_bh_get(rs->rs_rbm.rgd);
2079 rg_mblk_search(rs->rs_rbm.rgd, ip, ap);
2086 free_blocks = rgd_free(rs->rs_rbm.rgd, rs);
2095 if (rs->rs_rbm.rgd->rd_flags & GFS2_RDF_CHECK)
2096 try_rgrp_unlink(rs->rs_rbm.rgd, &last_unlinked,
2108 if (gfs2_select_rgrp(&rs->rs_rbm.rgd, begin))
2158 struct gfs2_rbm pos = { .rgd = rbm->rgd, };
2165 gfs2_trans_add_meta(rbm->rgd->rd_gl, rbm_bi(rbm)->bi_bh);
2172 gfs2_trans_add_meta(pos.rgd->rd_gl, rbm_bi(&pos)->bi_bh);
2182 * @rgd: the resource group the blocks are in
2188 static void rgblk_free(struct gfs2_sbd *sdp, struct gfs2_rgrpd *rgd,
2194 rbm.rgd = rgd;
2207 gfs2_trans_add_meta(rbm.rgd->rd_gl, bi->bi_bh);
2218 * @rgd: The rgrp in question
2223 void gfs2_rgrp_dump(struct seq_file *seq, struct gfs2_rgrpd *rgd,
2231 (unsigned long long)rgd->rd_addr, rgd->rd_flags,
2232 rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
2233 rgd->rd_reserved, rgd->rd_extfail_pt);
2234 if (rgd->rd_sbd->sd_args.ar_rgrplvb && rgd->rd_rgl) {
2235 struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
2242 spin_lock(&rgd->rd_rsspin);
2243 for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
2247 spin_unlock(&rgd->rd_rsspin);
2250 static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
2252 struct gfs2_sbd *sdp = rgd->rd_sbd;
2256 (unsigned long long)rgd->rd_addr);
2259 gfs2_rgrp_dump(NULL, rgd, fs_id_buf);
2260 rgd->rd_flags |= GFS2_RDF_ERROR;
2278 struct gfs2_rgrpd *rgd = rbm->rgd;
2283 spin_lock(&rgd->rd_rsspin);
2290 rgd->rd_reserved -= rlen;
2301 spin_unlock(&rgd->rd_rsspin);
2325 if (!dinode && rgrp_contains_block(rbm->rgd, ip->i_goal))
2328 goal = rbm->rgd->rd_last_alloc + rbm->rgd->rd_data0;
2352 struct gfs2_rbm rbm = { .rgd = ip->i_res.rs_rbm.rgd, };
2370 test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags),
2371 rbm.rgd->rd_extfail_pt);
2377 rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
2396 if (rbm.rgd->rd_free < *nblocks) {
2401 rbm.rgd->rd_free -= *nblocks;
2403 rbm.rgd->rd_dinodes++;
2404 *generation = rbm.rgd->rd_igeneration++;
2406 *generation = rbm.rgd->rd_igeneration++;
2409 gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh);
2410 gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
2418 rbm.rgd->rd_free_clone -= *nblocks;
2419 trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
2425 gfs2_rgrp_error(rbm.rgd);
2432 * @rgd: the resource group the blocks are in
2439 void __gfs2_free_blocks(struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
2444 rgblk_free(sdp, rgd, bstart, blen, GFS2_BLKST_FREE);
2445 trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
2446 rgd->rd_free += blen;
2447 rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
2448 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2449 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2459 * @rgd: the resource group the blocks are in
2465 void gfs2_free_meta(struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
2470 __gfs2_free_blocks(ip, rgd, bstart, blen, 1);
2479 struct gfs2_rgrpd *rgd;
2482 rgd = gfs2_blk2rgrpd(sdp, blkno, true);
2483 if (!rgd)
2485 rgblk_free(sdp, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
2486 trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
2487 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2488 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2489 be32_add_cpu(&rgd->rd_rgl->rl_unlinked, 1);
2492 void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
2494 struct gfs2_sbd *sdp = rgd->rd_sbd;
2496 rgblk_free(sdp, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
2497 if (!rgd->rd_dinodes)
2498 gfs2_consist_rgrpd(rgd);
2499 rgd->rd_dinodes--;
2500 rgd->rd_free++;
2502 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
2503 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
2504 be32_add_cpu(&rgd->rd_rgl->rl_unlinked, -1);
2507 trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
2525 struct gfs2_rgrpd *rgd;
2530 rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
2531 if (!rgd)
2534 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
2538 rbm.rgd = rgd;
2567 struct gfs2_rgrpd *rgd;
2580 rgd = rlist->rl_rgd[rlist->rl_rgrps - 1];
2581 if (rgrp_contains_block(rgd, block))
2583 rgd = gfs2_blk2rgrpd(sdp, block, 1);
2585 rgd = ip->i_res.rs_rbm.rgd;
2586 if (!rgd || !rgrp_contains_block(rgd, block))
2587 rgd = gfs2_blk2rgrpd(sdp, block, 1);
2590 if (!rgd) {
2597 if (rlist->rl_rgd[x] == rgd) {
2620 rlist->rl_rgd[rlist->rl_rgrps++] = rgd;