Use the lgfs2_ prefix in libgfs2 interface names.
Signed-off-by: Andrew Price <[email protected]>
---
gfs2/convert/gfs2_convert.c | 10 +++---
gfs2/edit/hexedit.c | 60 +++++++++++++++++-----------------
gfs2/edit/journal.c | 2 +-
gfs2/edit/savemeta.c | 2 +-
gfs2/fsck/fs_recovery.c | 2 +-
gfs2/fsck/fsck.h | 2 +-
gfs2/fsck/initialize.c | 6 ++--
gfs2/fsck/metawalk.c | 2 +-
gfs2/fsck/pass1.c | 2 +-
gfs2/fsck/pass5.c | 4 +--
gfs2/fsck/rgrepair.c | 64 ++++++++++++++++++-------------------
gfs2/fsck/util.h | 2 +-
gfs2/libgfs2/fs_bits.c | 2 +-
gfs2/libgfs2/fs_ops.c | 8 ++---
gfs2/libgfs2/gfs2l.c | 2 +-
gfs2/libgfs2/lang.c | 6 ++--
gfs2/libgfs2/libgfs2.h | 22 +++++--------
gfs2/libgfs2/rgrp.c | 22 ++++++-------
gfs2/libgfs2/super.c | 4 +--
19 files changed, 109 insertions(+), 115 deletions(-)
diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c
index 90964ae1..1608b1ad 100644
--- a/gfs2/convert/gfs2_convert.c
+++ b/gfs2/convert/gfs2_convert.c
@@ -1532,7 +1532,7 @@ static int gfs1_ri_update(struct gfs2_sbd *sdp, int
*rgcount, int quiet)
next = osi_next(n);
rgd = (struct rgrp_tree *)n;
/* Read resource group header */
- errblock = gfs2_rgrp_read(sdp, rgd);
+ errblock = lgfs2_rgrp_read(sdp, rgd);
if (errblock)
return errblock;
count2++;
@@ -1552,7 +1552,7 @@ static int gfs1_ri_update(struct gfs2_sbd *sdp, int
*rgcount, int quiet)
return 0;
fail:
- gfs2_rgrp_free(sdp, &sdp->rgtree);
+ lgfs2_rgrp_free(sdp, &sdp->rgtree);
return -1;
}
@@ -1848,7 +1848,7 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
ji_addr, rgdhigh->rt_addr);
ri_addr = ji_addr;
/* Allocate a new rgd entry which includes rg and ri. */
- rgd = rgrp_insert(&sdp->rgtree, ri_addr);
+ rgd = lgfs2_rgrp_insert(&sdp->rgtree, ri_addr);
/* convert the gfs1 rgrp into a new gfs2 rgrp */
size = ji_nsegs * be32_to_cpu(gfs1_sb.sb_seg_size);
rgd->rt_flags = 0;
@@ -1866,7 +1866,7 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
rgd->rt_free = rgd->rt_data;
rgd->rt_bitbytes = rgd->rt_data / GFS2_NBBY;
- if (gfs2_compute_bitstructs(sdp->sd_bsize, rgd)) {
+ if (lgfs2_compute_bitstructs(sdp->sd_bsize, rgd)) {
log_crit(_("gfs2_convert: Error converting
bitmaps.\n"));
exit(-1);
}
@@ -2382,7 +2382,7 @@ int main(int argc, char **argv)
fsync(sb2.device_fd); /* write the buffers to disk */
/* Now free all the in memory */
- gfs2_rgrp_free(&sb2, &sb2.rgtree);
+ lgfs2_rgrp_free(&sb2, &sb2.rgtree);
log_notice(_("Committing changes to disk.\n"));
fflush(stdout);
/* Set filesystem type in superblock to gfs2. We do this at
the */
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index ffb714bf..b0f110c1 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -350,9 +350,9 @@ int display_block_type(char *buf, uint64_t addr, int
from_restore)
int type;
struct rgrp_tree *rgd;
- rgd = gfs2_blk2rgrpd(&sbd, block);
+ rgd = lgfs2_blk2rgrpd(&sbd, block);
if (rgd) {
- gfs2_rgrp_read(&sbd, rgd);
+ lgfs2_rgrp_read(&sbd, rgd);
if ((be32_to_cpu(mh->mh_type) == GFS2_METATYPE_RG) ||
(be32_to_cpu(mh->mh_type) == GFS2_METATYPE_RB))
type = 4;
@@ -428,7 +428,7 @@ int display_block_type(char *buf, uint64_t addr, int
from_restore)
}
}
if (rgd)
- gfs2_rgrp_relse(&sbd, rgd);
+ lgfs2_rgrp_relse(&sbd, rgd);
}
if (block == sbd.sd_root_dir.in_addr)
print_gfs2("--------------- Root directory ------------------");
@@ -693,7 +693,7 @@ static void rgcount(void)
printf("%"PRId64" RGs in this file system.\n",
sbd.md.riinode->i_size / sizeof(struct gfs2_rindex));
lgfs2_inode_put(&sbd.md.riinode);
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_SUCCESS);
}
@@ -1154,7 +1154,7 @@ static uint64_t find_metablockoftype_slow(uint64_t
startblk, int metatype, int p
else
printf("%"PRIu64"\n", blk);
}
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
if (print)
exit(0);
return blk;
@@ -1216,13 +1216,13 @@ static uint64_t find_metablockoftype_rg(uint64_t
startblk, int metatype, int pri
if (!rgd) {
if (print)
printf("0\n");
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
if (print)
exit(-1);
}
for (; !found && next; next = osi_next(next)){
rgd = (struct rgrp_tree *)next;
- errblk = gfs2_rgrp_read(&sbd, rgd);
+ errblk = lgfs2_rgrp_read(&sbd, rgd);
if (errblk)
continue;
@@ -1230,7 +1230,7 @@ static uint64_t find_metablockoftype_rg(uint64_t
startblk, int metatype, int pri
if (found)
break;
- gfs2_rgrp_relse(&sbd, rgd);
+ lgfs2_rgrp_relse(&sbd, rgd);
}
if (!found)
@@ -1241,7 +1241,7 @@ static uint64_t find_metablockoftype_rg(uint64_t
startblk, int metatype, int pri
else
printf("%"PRIu64"\n", blk);
}
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
if (print)
exit(0);
return blk;
@@ -1275,7 +1275,7 @@ static uint64_t find_metablockoftype(const char *strtype,
int print)
"specified: must be one of:\n");
fprintf(stderr, "sb rg rb di in lf jd lh ld"
" ea ed lb 13 qc\n");
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(-1);
}
return blk;
@@ -1589,7 +1589,7 @@ static void find_print_block_type(void)
type = get_block_type(lbh->b_data);
print_block_type(tblock, type);
lgfs2_brelse(lbh);
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(0);
}
@@ -1606,7 +1606,7 @@ static void find_print_block_rg(int bitmap)
if (rblock == LGFS2_SB_ADDR(&sbd))
printf("0 (the superblock is not in the bitmap)\n");
else {
- rgd = gfs2_blk2rgrpd(&sbd, rblock);
+ rgd = lgfs2_blk2rgrpd(&sbd, rblock);
if (rgd) {
rgblock = rgd->rt_addr;
if (bitmap) {
@@ -1632,7 +1632,7 @@ static void find_print_block_rg(int bitmap)
printf("-1 (block invalid or part of an rgrp).\n");
}
}
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(0);
}
@@ -1653,16 +1653,16 @@ static void find_change_block_alloc(int *newval)
*newval);
for (i = GFS2_BLKST_FREE; i <= GFS2_BLKST_DINODE; i++)
printf("%d - %s\n", i, allocdesc[sbd.gfs1][i]);
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(-1);
}
ablock = blockstack[blockhist % BLOCK_STACK_SIZE].block;
if (ablock == LGFS2_SB_ADDR(&sbd))
printf("3 (the superblock is not in the bitmap)\n");
else {
- rgd = gfs2_blk2rgrpd(&sbd, ablock);
+ rgd = lgfs2_blk2rgrpd(&sbd, ablock);
if (rgd) {
- gfs2_rgrp_read(&sbd, rgd);
+ lgfs2_rgrp_read(&sbd, rgd);
if (newval) {
if (lgfs2_set_bitmap(rgd, ablock, *newval))
printf("-1 (block invalid or part of an
rgrp).\n");
@@ -1677,14 +1677,14 @@ static void find_change_block_alloc(int *newval)
}
printf("%d (%s)\n", type,
allocdesc[sbd.gfs1][type]);
}
- gfs2_rgrp_relse(&sbd, rgd);
+ lgfs2_rgrp_relse(&sbd, rgd);
} else {
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
printf("-1 (block invalid or part of an rgrp).\n");
exit(-1);
}
}
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
if (newval)
fsync(sbd.device_fd);
exit(0);
@@ -2184,8 +2184,8 @@ static void rg_repair(void)
/* Walk through the resource groups saving everything within */
for (n = osi_first(&sbd.rgtree); n; n = osi_next(n)) {
rgd = (struct rgrp_tree *)n;
- if (gfs2_rgrp_read(&sbd, rgd) == 0) { /* was read in okay */
- gfs2_rgrp_relse(&sbd, rgd);
+ if (lgfs2_rgrp_read(&sbd, rgd) == 0) { /* was read in okay */
+ lgfs2_rgrp_relse(&sbd, rgd);
continue; /* ignore it */
}
/* If we get here, it's because we have an rgrp in the rindex
@@ -2374,7 +2374,7 @@ static void process_parameters(int argc, char *argv[],
int pass)
printf("Error: field not specified.\n");
printf("Format is: %s -p <block> field "
"<field> [newvalue]\n", argv[0]);
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_FAILURE);
}
process_field(argv[i], argv[i + 1]);
@@ -2407,7 +2407,7 @@ static void process_parameters(int argc, char *argv[],
int pass)
printf("Error: rg # not specified.\n");
printf("Format is: %s rgflags rgnum"
"[newvalue]\n", argv[0]);
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_FAILURE);
}
if (argv[i][0]=='0' && argv[i][1]=='x')
@@ -2424,7 +2424,7 @@ static void process_parameters(int argc, char *argv[],
int pass)
new_flags = atoi(argv[i]);
}
set_rgrp_flags(rg, new_flags, set, FALSE);
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_SUCCESS);
} else if (!strcmp(argv[i], "rg")) {
int rg;
@@ -2433,7 +2433,7 @@ static void process_parameters(int argc, char *argv[],
int pass)
if (i >= argc - 1) {
printf("Error: rg # not specified.\n");
printf("Format is: %s rg rgnum\n", argv[0]);
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_FAILURE);
}
rg = atoi(argv[i]);
@@ -2442,7 +2442,7 @@ static void process_parameters(int argc, char *argv[],
int pass)
push_block(temp_blk);
} else {
set_rgrp_flags(rg, 0, FALSE, TRUE);
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_SUCCESS);
}
} else if (!strcmp(argv[i], "rgbitmaps")) {
@@ -2455,15 +2455,15 @@ static void process_parameters(int argc, char *argv[],
int pass)
printf("Error: rg # not specified.\n");
printf("Format is: %s rgbitmaps rgnum\n",
argv[0]);
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_FAILURE);
}
rg = atoi(argv[i]);
rgblk = get_rg_addr(rg);
- rgd = gfs2_blk2rgrpd(&sbd, rgblk);
+ rgd = lgfs2_blk2rgrpd(&sbd, rgblk);
if (rgd == NULL) {
printf("Error: rg # is invalid.\n");
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_FAILURE);
}
for (bmap = 0; bmap < rgd->rt_length; bmap++)
@@ -2574,7 +2574,7 @@ int main(int argc, char *argv[])
close(fd);
if (indirect)
free(indirect);
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_SUCCESS);
}
#endif /* UNITTESTS */
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index 91d0a925..2bc94514 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -546,7 +546,7 @@ void dump_journal(const char *journal, uint64_t tblk)
if (tblk) {
uint64_t wp;
- rgd = gfs2_blk2rgrpd(&sbd, tblk);
+ rgd = lgfs2_blk2rgrpd(&sbd, tblk);
if (!rgd) {
print_gfs2("Can't locate the rgrp for block 0x%"PRIx64,
tblk);
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 1d22df2e..21c67989 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -1207,7 +1207,7 @@ void savemeta(char *out_fn, int saveoption, int gziplevel)
close(sbd.device_fd);
destroy_per_node_lookup();
free(indirect);
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(0);
}
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index 6f186c92..bd0fd731 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -167,7 +167,7 @@ static int buf_lo_scan_elements(struct gfs2_inode *ip,
unsigned int start,
error = -EIO;
} else {
lgfs2_bmodified(bh_ip);
- rgd = gfs2_blk2rgrpd(sdp, blkno);
+ rgd = lgfs2_blk2rgrpd(sdp, blkno);
if (rgd && blkno < rgd->rt_data0)
refresh_rgrp(sdp, rgd, bh_ip, blkno);
}
diff --git a/gfs2/fsck/fsck.h b/gfs2/fsck/fsck.h
index 7b991614..055ae975 100644
--- a/gfs2/fsck/fsck.h
+++ b/gfs2/fsck/fsck.h
@@ -183,7 +183,7 @@ static inline int valid_block_ip(struct gfs2_inode *ip,
uint64_t blk)
if (blk <= LGFS2_SB_ADDR(sdp))
return 0;
if (rgd == NULL || !rgrp_contains_block(rgd, blk)) {
- rgd = gfs2_blk2rgrpd(sdp, blk);
+ rgd = lgfs2_blk2rgrpd(sdp, blk);
if (rgd == NULL)
return 0;
}
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index f1586374..18522a35 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -112,7 +112,7 @@ static void gfs2_inodetree_free(void)
static void empty_super_block(struct gfs2_sbd *sdp)
{
log_info( _("Freeing buffers.\n"));
- gfs2_rgrp_free(sdp, &sdp->rgtree);
+ lgfs2_rgrp_free(sdp, &sdp->rgtree);
gfs2_inodetree_free();
gfs2_dirtree_free();
@@ -675,7 +675,7 @@ static int read_rgrps(struct gfs2_sbd *sdp, uint64_t
expected)
if (ra_window < RA_WINDOW/2)
ra_window = gfs2_rgrp_reada(sdp, ra_window, n);
/* Read resource group header */
- errblock = gfs2_rgrp_read(sdp, rgd);
+ errblock = lgfs2_rgrp_read(sdp, rgd);
if (errblock)
return errblock;
ra_window--;
@@ -693,7 +693,7 @@ static int read_rgrps(struct gfs2_sbd *sdp, uint64_t
expected)
fail:
posix_fadvise(sdp->device_fd, 0, 0, POSIX_FADV_NORMAL);
- gfs2_rgrp_free(sdp, &sdp->rgtree);
+ lgfs2_rgrp_free(sdp, &sdp->rgtree);
return -1;
}
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index a401e792..2612b0cb 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -44,7 +44,7 @@ int check_n_fix_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree
*rgd,
if (prevrgd && rgrp_contains_block(prevrgd, blk)) {
rgd = prevrgd;
} else if (rgd == NULL || !rgrp_contains_block(rgd, blk)) {
- rgd = gfs2_blk2rgrpd(sdp, blk);
+ rgd = lgfs2_blk2rgrpd(sdp, blk);
prevrgd = rgd;
}
old_state = lgfs2_get_bitmap(sdp, blk, rgd);
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 2b3379a7..f747a7a5 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -430,7 +430,7 @@ static int undo_reference(struct gfs2_inode *ip, uint64_t
block, int meta,
}
}
if (!meta) {
- rgd = gfs2_blk2rgrpd(ip->i_sbd, block);
+ rgd = lgfs2_blk2rgrpd(ip->i_sbd, block);
old_bitmap_state = lgfs2_get_bitmap(ip->i_sbd, block, rgd);
if (old_bitmap_state == GFS2_BLKST_DINODE)
return -1;
diff --git a/gfs2/fsck/pass5.c b/gfs2/fsck/pass5.c
index 976c8641..9aba38e6 100644
--- a/gfs2/fsck/pass5.c
+++ b/gfs2/fsck/pass5.c
@@ -68,7 +68,7 @@ static int check_block_status(struct gfs2_sbd *sdp, struct
gfs2_bmap *bl,
block, block);
if (query(_("Do you want to reclaim the block? "
"(y/n) "))) {
- lgfs2_rgrp_t rg = gfs2_blk2rgrpd(sdp, block);
+ lgfs2_rgrp_t rg = lgfs2_blk2rgrpd(sdp, block);
if (lgfs2_set_bitmap(rg, block,
GFS2_BLKST_FREE))
log_err(_("Unlinked block %"PRIu64"
(0x%"PRIx64") bitmap not fixed.\n"),
block, block);
@@ -93,7 +93,7 @@ static int check_block_status(struct gfs2_sbd *sdp, struct
gfs2_bmap *bl,
if (query(_("Fix bitmap for block %"PRIu64"
(0x%"PRIx64")? (y/n) "),
block, block)) {
- lgfs2_rgrp_t rg = gfs2_blk2rgrpd(sdp, block);
+ lgfs2_rgrp_t rg = lgfs2_blk2rgrpd(sdp, block);
if (lgfs2_set_bitmap(rg, block, q))
log_err( _("Repair failed.\n"));
else
diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c
index 6f15d2d4..8c2dd35d 100644
--- a/gfs2/fsck/rgrepair.c
+++ b/gfs2/fsck/rgrepair.c
@@ -557,7 +557,7 @@ static int rindex_rebuild(struct gfs2_sbd *sdp, int
*num_rgs, int gfs_grow)
rg_was_fnd = (!lgfs2_check_meta(bh->b_data, GFS2_METATYPE_RG));
lgfs2_brelse(bh);
/* Allocate a new RG and index. */
- calc_rgd = rgrp_insert(&rgcalc, blk);
+ calc_rgd = lgfs2_rgrp_insert(&rgcalc, blk);
if (!calc_rgd) {
log_crit( _("Can't allocate memory for rgrp
repair.\n"));
goto out;
@@ -597,7 +597,7 @@ static int rindex_rebuild(struct gfs2_sbd *sdp, int
*num_rgs, int gfs_grow)
if (prev_rgd) {
uint32_t rgblocks;
- prev_rgd->rt_length = rgblocks2bitblocks(sdp->sd_bsize,
block_bump, &rgblocks);
+ prev_rgd->rt_length =
lgfs2_rgblocks2bitblocks(sdp->sd_bsize, block_bump, &rgblocks);
prev_rgd->rt_data = rgblocks;
prev_rgd->rt_data0 = prev_rgd->rt_addr +
prev_rgd->rt_length;
@@ -657,7 +657,7 @@ static int rindex_rebuild(struct gfs2_sbd *sdp, int
*num_rgs, int gfs_grow)
if (prev_rgd && !prev_rgd->rt_data) {
uint32_t rgblocks;
- prev_rgd->rt_length = rgblocks2bitblocks(sdp->sd_bsize,
block_bump, &rgblocks);
+ prev_rgd->rt_length = lgfs2_rgblocks2bitblocks(sdp->sd_bsize,
block_bump, &rgblocks);
prev_rgd->rt_data0 = prev_rgd->rt_addr + prev_rgd->rt_length;
prev_rgd->rt_data = rgblocks;
prev_rgd->rt_data -= prev_rgd->rt_data % GFS2_NBBY;
@@ -705,9 +705,9 @@ static uint64_t how_many_rgrps(struct gfs2_sbd *sdp, struct
device *dev)
nrgrp = DIV_RU(dev->length, (sdp->rgsize << 20) /
sdp->sd_bsize);
/* check to see if the rg length overflows max # bitblks */
- bitblocksn = rgblocks2bitblocks(sdp->sd_bsize, dev->length /
nrgrp, &rgblocksn);
+ bitblocksn = lgfs2_rgblocks2bitblocks(sdp->sd_bsize,
dev->length / nrgrp, &rgblocksn);
/* calculate size of the first rgrp */
- bitblocks1 = rgblocks2bitblocks(sdp->sd_bsize, dev->length -
(nrgrp - 1) * (dev->length / nrgrp),
+ bitblocks1 = lgfs2_rgblocks2bitblocks(sdp->sd_bsize,
dev->length - (nrgrp - 1) * (dev->length / nrgrp),
&rgblocks1);
if (bitblocks1 <= 2149 && bitblocksn <= 2149)
break;
@@ -749,11 +749,11 @@ static struct osi_root compute_rgrp_layout(struct
gfs2_sbd *sdp)
for (; rgrp < nrgrp; rgrp++) {
if (rgrp) {
rgaddr = rlast->rt_addr + rlast->rt_skip;
- rl = rgrp_insert(&rgtree, rgaddr);
+ rl = lgfs2_rgrp_insert(&rgtree, rgaddr);
rl->rt_skip = rglength;
} else {
rgaddr = LGFS2_SB_ADDR(sdp) + 1;
- rl = rgrp_insert(&rgtree, rgaddr);
+ rl = lgfs2_rgrp_insert(&rgtree, rgaddr);
rl->rt_skip = dev->length -
(nrgrp - 1) * (dev->length / nrgrp);
}
@@ -774,7 +774,7 @@ static int calc_rgrps(struct gfs2_sbd *sdp)
next = osi_next(n);
rl = (struct rgrp_tree *)n;
- bitblocks = rgblocks2bitblocks(sdp->sd_bsize, rl->rt_skip,
&rgblocks);
+ bitblocks = lgfs2_rgblocks2bitblocks(sdp->sd_bsize,
rl->rt_skip, &rgblocks);
rl->rt_length = bitblocks;
rl->rt_data0 = rl->rt_addr + bitblocks;
@@ -782,7 +782,7 @@ static int calc_rgrps(struct gfs2_sbd *sdp)
rl->rt_bitbytes = rgblocks / GFS2_NBBY;
rl->rt_free = rgblocks;
- if (gfs2_compute_bitstructs(sdp->sd_bsize, rl))
+ if (lgfs2_compute_bitstructs(sdp->sd_bsize, rl))
return -1;
sdp->blks_total += rgblocks;
@@ -911,7 +911,7 @@ static int expect_rindex_sanity(struct gfs2_sbd *sdp, int
*num_rgs)
for (n = osi_first(&sdp->rgtree); n; n = next) {
next = osi_next(n);
rgd = (struct rgrp_tree *)n;
- exp = rgrp_insert(&rgcalc, rgd->rt_addr);
+ exp = lgfs2_rgrp_insert(&rgcalc, rgd->rt_addr);
if (exp == NULL) {
fprintf(stderr, "Out of memory in %s\n", __FUNCTION__);
exit(-1);
@@ -926,7 +926,7 @@ static int expect_rindex_sanity(struct gfs2_sbd *sdp, int
*num_rgs)
exp->rt_dinodes = rgd->rt_dinodes;
exp->rt_skip = rgd->rt_skip;
exp->bits = NULL;
- gfs2_compute_bitstructs(sdp->sd_bsize, exp);
+ lgfs2_compute_bitstructs(sdp->sd_bsize, exp);
}
sdp->rgrps = *num_rgs;
return 0;
@@ -955,7 +955,7 @@ int rindex_repair(struct gfs2_sbd *sdp, int trust_lvl, int
*ok)
if (trust_lvl == YE_OF_LITTLE_FAITH) { /* if rindex seems sane */
/* Don't free previous incarnations in memory, if any.
* We need them to copy in the next function:
- * gfs2_rgrp_free(&sdp->rglist); */
+ * lgfs2_rgrp_free(&sdp->rglist); */
if (!(*ok)) {
log_err(_("The rindex file does not meet our "
"expectations.\n"));
@@ -963,37 +963,37 @@ int rindex_repair(struct gfs2_sbd *sdp, int trust_lvl,
int *ok)
}
error = expect_rindex_sanity(sdp, &calc_rg_count);
if (error) {
- gfs2_rgrp_free(sdp, &rgcalc);
+ lgfs2_rgrp_free(sdp, &rgcalc);
return error;
}
} else if (trust_lvl == OPEN_MINDED) { /* If we can't trust RG index */
/* Free previous incarnations in memory, if any. */
- gfs2_rgrp_free(sdp, &sdp->rgtree);
+ lgfs2_rgrp_free(sdp, &sdp->rgtree);
/* Calculate our own RG index for comparison */
error = gfs2_rindex_calculate(sdp, &calc_rg_count);
if (error) { /* If calculated RGs don't match the fs */
- gfs2_rgrp_free(sdp, &rgcalc);
+ lgfs2_rgrp_free(sdp, &rgcalc);
return -1;
}
} else if (trust_lvl == DISTRUST) { /* If we can't trust RG index */
/* Free previous incarnations in memory, if any. */
- gfs2_rgrp_free(sdp, &sdp->rgtree);
+ lgfs2_rgrp_free(sdp, &sdp->rgtree);
error = rindex_rebuild(sdp, &calc_rg_count, 0);
if (error) {
log_crit( _("Error rebuilding rgrp list.\n"));
- gfs2_rgrp_free(sdp, &rgcalc);
+ lgfs2_rgrp_free(sdp, &rgcalc);
return -1;
}
} else if (trust_lvl == INDIGNATION) { /* If we can't trust anything */
/* Free previous incarnations in memory, if any. */
- gfs2_rgrp_free(sdp, &sdp->rgtree);
+ lgfs2_rgrp_free(sdp, &sdp->rgtree);
error = rindex_rebuild(sdp, &calc_rg_count, 1);
if (error) {
log_crit( _("Error rebuilding rgrp list.\n"));
- gfs2_rgrp_free(sdp, &rgcalc);
+ lgfs2_rgrp_free(sdp, &rgcalc);
return -1;
}
}
@@ -1004,8 +1004,8 @@ int rindex_repair(struct gfs2_sbd *sdp, int trust_lvl,
int *ok)
log_warn( _("WARNING: rindex file has an invalid size.\n"));
if (!query( _("Truncate the rindex size? (y/n)"))) {
log_err(_("The rindex was not repaired.\n"));
- gfs2_rgrp_free(sdp, &rgcalc);
- gfs2_rgrp_free(sdp, &sdp->rgtree);
+ lgfs2_rgrp_free(sdp, &rgcalc);
+ lgfs2_rgrp_free(sdp, &sdp->rgtree);
return -1;
}
sdp->md.riinode->i_size /= sizeof(struct gfs2_rindex);
@@ -1028,8 +1028,8 @@ int rindex_repair(struct gfs2_sbd *sdp, int trust_lvl,
int *ok)
then try again with a little more DISTRUST. */
if ((trust_lvl < DISTRUST) ||
!query( _("Attempt to use what rgrps we can? (y/n)"))) {
- gfs2_rgrp_free(sdp, &rgcalc);
- gfs2_rgrp_free(sdp, &sdp->rgtree);
+ lgfs2_rgrp_free(sdp, &rgcalc);
+ lgfs2_rgrp_free(sdp, &sdp->rgtree);
log_err(_("The rindex was not repaired.\n"));
return -1;
}
@@ -1094,8 +1094,8 @@ int rindex_repair(struct gfs2_sbd *sdp, int trust_lvl,
int *ok)
log_warn( _("%d out of %d rgrps (%d percent) did not "
"match what was expected.\n"),
discrepancies, rg, percent);
- gfs2_rgrp_free(sdp, &rgcalc);
- gfs2_rgrp_free(sdp, &sdp->rgtree);
+ lgfs2_rgrp_free(sdp, &rgcalc);
+ lgfs2_rgrp_free(sdp, &sdp->rgtree);
return -1;
}
}
@@ -1124,7 +1124,7 @@ int rindex_repair(struct gfs2_sbd *sdp, int trust_lvl,
int *ok)
expected->rt_addr < actual->rt_addr) {
log_err(_("Entry missing from rindex: 0x%"PRIx64"\n"),
expected->rt_addr);
- actual = rgrp_insert(&sdp->rgtree, expected->rt_addr);
+ actual = lgfs2_rgrp_insert(&sdp->rgtree,
expected->rt_addr);
if (!actual) {
log_err(_("Out of memory!\n"));
break;
@@ -1152,7 +1152,7 @@ int rindex_repair(struct gfs2_sbd *sdp, int trust_lvl,
int *ok)
actual->rt_data = expected->rt_data;
actual->rt_bitbytes = expected->rt_bitbytes;
/* If our rindex was hosed, ri_length is bad */
- /* Therefore, gfs2_compute_bitstructs might */
+ /* Therefore, lgfs2_compute_bitstructs might */
/* have malloced the wrong length for bitmap */
/* buffers. So we have to redo it. */
if (actual->bits) {
@@ -1162,7 +1162,7 @@ int rindex_repair(struct gfs2_sbd *sdp, int trust_lvl,
int *ok)
}
else
log_err( _("rindex not fixed.\n"));
- gfs2_compute_bitstructs(sdp->sd_bsize, actual);
+ lgfs2_compute_bitstructs(sdp->sd_bsize, actual);
rindex_modified = 0;
}
e = enext;
@@ -1186,21 +1186,21 @@ int rindex_repair(struct gfs2_sbd *sdp, int trust_lvl,
int *ok)
i = 0;
do {
rgd = (struct rgrp_tree *)n;
- errblock = gfs2_rgrp_read(sdp, rgd);
+ errblock = lgfs2_rgrp_read(sdp, rgd);
if (errblock) {
if (errblock == prev_err)
break;
prev_err = errblock;
rewrite_rg_block(sdp, rgd, errblock);
} else {
- gfs2_rgrp_relse(sdp, rgd);
+ lgfs2_rgrp_relse(sdp, rgd);
break;
}
i++;
} while (i < rgd->rt_length);
}
- gfs2_rgrp_free(sdp, &rgcalc);
- gfs2_rgrp_free(sdp, &sdp->rgtree);
+ lgfs2_rgrp_free(sdp, &rgcalc);
+ lgfs2_rgrp_free(sdp, &sdp->rgtree);
/* We shouldn't need to worry about getting the user's permission to
make changes here. If b_modified is true, they already gave their
permission. */
diff --git a/gfs2/fsck/util.h b/gfs2/fsck/util.h
index ae654bf4..278ac139 100644
--- a/gfs2/fsck/util.h
+++ b/gfs2/fsck/util.h
@@ -68,7 +68,7 @@ static inline int bitmap_type(struct gfs2_sbd *sdp, uint64_t
bblock)
{
struct rgrp_tree *rgd;
- rgd = gfs2_blk2rgrpd(sdp, bblock);
+ rgd = lgfs2_blk2rgrpd(sdp, bblock);
return lgfs2_get_bitmap(sdp, bblock, rgd);
}
diff --git a/gfs2/libgfs2/fs_bits.c b/gfs2/libgfs2/fs_bits.c
index 940ebf3c..db5e2772 100644
--- a/gfs2/libgfs2/fs_bits.c
+++ b/gfs2/libgfs2/fs_bits.c
@@ -183,7 +183,7 @@ int lgfs2_get_bitmap(struct gfs2_sbd *sdp, uint64_t blkno,
struct rgrp_tree *rgd
struct gfs2_bitmap *bi;
if (rgd == NULL) {
- rgd = gfs2_blk2rgrpd(sdp, blkno);
+ rgd = lgfs2_blk2rgrpd(sdp, blkno);
if(rgd == NULL)
return -1;
}
diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index 1d5ef8e6..4e10ab4f 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
@@ -178,7 +178,7 @@ static int block_alloc(struct gfs2_sbd *sdp, const uint64_t
blksreq, int state,
return -1;
if (rgt->bits[0].bi_data == NULL) {
- if (gfs2_rgrp_read(sdp, rgt))
+ if (lgfs2_rgrp_read(sdp, rgt))
return -1;
release = 1;
}
@@ -186,7 +186,7 @@ static int block_alloc(struct gfs2_sbd *sdp, const uint64_t
blksreq, int state,
bn = find_free_block(rgt);
ret = blk_alloc_in_rg(sdp, state, rgt, bn, dinode);
if (release)
- gfs2_rgrp_relse(sdp, rgt);
+ lgfs2_rgrp_relse(sdp, rgt);
*blkno = bn;
return ret;
}
@@ -1900,7 +1900,7 @@ void lgfs2_free_block(struct gfs2_sbd *sdp, uint64_t
block)
struct rgrp_tree *rgd;
/* Adjust the free space count for the freed block */
- rgd = gfs2_blk2rgrpd(sdp, block); /* find the rg for indir block */
+ rgd = lgfs2_blk2rgrpd(sdp, block); /* find the rg for indir block */
if (rgd) {
lgfs2_set_bitmap(rgd, block, GFS2_BLKST_FREE);
rgd->rt_free++; /* adjust the free count */
@@ -1967,7 +1967,7 @@ int lgfs2_freedi(struct gfs2_sbd *sdp, uint64_t diblock)
}
}
}
- rgd = gfs2_blk2rgrpd(sdp, diblock);
+ rgd = lgfs2_blk2rgrpd(sdp, diblock);
lgfs2_set_bitmap(rgd, diblock, GFS2_BLKST_FREE);
lgfs2_inode_put(&ip);
/* lgfs2_inode_put deallocated the extra block used by the disk inode,
*/
diff --git a/gfs2/libgfs2/gfs2l.c b/gfs2/libgfs2/gfs2l.c
index c31748b0..2ec4a1a1 100644
--- a/gfs2/libgfs2/gfs2l.c
+++ b/gfs2/libgfs2/gfs2l.c
@@ -190,7 +190,7 @@ int main(int argc, char *argv[])
lgfs2_lang_result_free(&result);
}
- gfs2_rgrp_free(&sbd, &sbd.rgtree);
+ lgfs2_rgrp_free(&sbd, &sbd.rgtree);
lgfs2_inode_put(&sbd.md.riinode);
lgfs2_inode_put(&sbd.master_dir);
lgfs2_lang_free(&state);
diff --git a/gfs2/libgfs2/lang.c b/gfs2/libgfs2/lang.c
index 57849e60..e1c5aba0 100644
--- a/gfs2/libgfs2/lang.c
+++ b/gfs2/libgfs2/lang.c
@@ -365,13 +365,13 @@ static int ast_get_bitstate(uint64_t bn, struct gfs2_sbd
*sbd)
{
int ret = 0;
int state = 0;
- struct rgrp_tree *rgd = gfs2_blk2rgrpd(sbd, bn);
+ struct rgrp_tree *rgd = lgfs2_blk2rgrpd(sbd, bn);
if (rgd == NULL) {
fprintf(stderr, "Could not find resource group for block
%"PRIu64"\n", bn);
return -1;
}
- ret = gfs2_rgrp_read(sbd, rgd);
+ ret = lgfs2_rgrp_read(sbd, rgd);
if (ret != 0) {
fprintf(stderr, "Failed to read resource group for block
%"PRIu64": %d\n", bn, ret);
return -1;
@@ -383,7 +383,7 @@ static int ast_get_bitstate(uint64_t bn, struct gfs2_sbd
*sbd)
return -1;
}
- gfs2_rgrp_relse(sbd, rgd);
+ lgfs2_rgrp_relse(sbd, rgd);
return state;
}
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index 5eb08baf..b204b763 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -490,9 +490,6 @@ extern int lgfs2_check_range(struct gfs2_sbd *sdp, uint64_t
blkno);
extern int lgfs2_get_bitmap(struct gfs2_sbd *sdp, uint64_t blkno, struct
rgrp_tree *rgd);
extern int lgfs2_set_bitmap(lgfs2_rgrp_t rg, uint64_t blkno, int state);
-extern uint32_t rgblocks2bitblocks(const unsigned int bsize, const uint32_t
rgblocks,
- uint32_t *ri_data)
__attribute__((nonnull(3)));
-
/* fs_ops.c */
#define IS_LEAF (1)
#define IS_DINODE (2)
@@ -746,20 +743,17 @@ extern int lgfs2_find_jhead(struct gfs2_inode *ip, struct
lgfs2_log_header *head
extern int lgfs2_clean_journal(struct gfs2_inode *ip, struct lgfs2_log_header
*head);
/* rgrp.c */
-extern int gfs2_compute_bitstructs(const uint32_t bsize, struct rgrp_tree
*rgd);
-extern struct rgrp_tree *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, uint64_t blk);
+extern uint32_t lgfs2_rgblocks2bitblocks(const unsigned int bsize, const
uint32_t rgblocks,
+ uint32_t *ri_data)
__attribute__((nonnull(3)));
+extern int lgfs2_compute_bitstructs(const uint32_t bsize, struct rgrp_tree
*rgd);
+extern struct rgrp_tree *lgfs2_blk2rgrpd(struct gfs2_sbd *sdp, uint64_t blk);
extern int lgfs2_rgrp_crc_check(char *buf);
extern void lgfs2_rgrp_crc_set(char *buf);
-extern uint64_t gfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd);
-extern void gfs2_rgrp_relse(struct gfs2_sbd *sdp, struct rgrp_tree *rgd);
-extern struct rgrp_tree *rgrp_insert(struct osi_root *rgtree,
+extern uint64_t lgfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd);
+extern void lgfs2_rgrp_relse(struct gfs2_sbd *sdp, struct rgrp_tree *rgd);
+extern struct rgrp_tree *lgfs2_rgrp_insert(struct osi_root *rgtree,
uint64_t rgblock);
-extern void gfs2_rgrp_free(struct gfs2_sbd *sdp, struct osi_root *rgrp_tree);
-/* figure out the size of the given resource group, in blocks */
-static inline unsigned int rgrp_size(struct rgrp_tree *rgrp)
-{
- return rgrp->rt_data + rgrp->rt_length;
-}
+extern void lgfs2_rgrp_free(struct gfs2_sbd *sdp, struct osi_root *rgrp_tree);
/* structures.c */
extern int lgfs2_build_master(struct gfs2_sbd *sdp);
diff --git a/gfs2/libgfs2/rgrp.c b/gfs2/libgfs2/rgrp.c
index 39b8b69b..a359f2fe 100644
--- a/gfs2/libgfs2/rgrp.c
+++ b/gfs2/libgfs2/rgrp.c
@@ -30,12 +30,12 @@ static void compute_bitmaps(lgfs2_rgrp_t rg, const unsigned
bsize)
}
/**
- * gfs2_compute_bitstructs - Compute the bitmap sizes
+ * lgfs2_compute_bitstructs - Compute the bitmap sizes
* bsize: Block size
* rgd: The resource group descriptor
* Returns: 0 on success, -1 on error
*/
-int gfs2_compute_bitstructs(const uint32_t bsize, struct rgrp_tree *rgd)
+int lgfs2_compute_bitstructs(const uint32_t bsize, struct rgrp_tree *rgd)
{
uint32_t length = rgd->rt_length;
uint32_t bytes_left;
@@ -86,7 +86,7 @@ errbits:
*
* Returns: Ths resource group, or NULL if not found
*/
-struct rgrp_tree *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, uint64_t blk)
+struct rgrp_tree *lgfs2_blk2rgrpd(struct gfs2_sbd *sdp, uint64_t blk)
{
struct rgrp_tree *rgd = (struct rgrp_tree *)sdp->rgtree.osi_node;
while (rgd) {
@@ -183,11 +183,11 @@ void lgfs2_rgrp_crc_set(char *buf)
}
/**
- * gfs2_rgrp_read - read in the resource group information from disk.
+ * lgfs2_rgrp_read - read in the resource group information from disk.
* @rgd - resource group structure
* returns: 0 if no error, otherwise the block number that failed
*/
-uint64_t gfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
+uint64_t lgfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
{
unsigned length = rgd->rt_length * sdp->sd_bsize;
off_t offset = rgd->rt_addr * sdp->sd_bsize;
@@ -227,7 +227,7 @@ uint64_t gfs2_rgrp_read(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd)
return 0;
}
-void gfs2_rgrp_relse(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
+void lgfs2_rgrp_relse(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
{
if (rgd->bits == NULL)
return;
@@ -250,7 +250,7 @@ void gfs2_rgrp_relse(struct gfs2_sbd *sdp, struct rgrp_tree
*rgd)
rgd->bits[i].bi_data = NULL;
}
-struct rgrp_tree *rgrp_insert(struct osi_root *rgtree, uint64_t rgblock)
+struct rgrp_tree *lgfs2_rgrp_insert(struct osi_root *rgtree, uint64_t rgblock)
{
struct osi_node **newn = &rgtree->osi_node, *parent = NULL;
struct rgrp_tree *data;
@@ -279,7 +279,7 @@ struct rgrp_tree *rgrp_insert(struct osi_root *rgtree,
uint64_t rgblock)
return data;
}
-void gfs2_rgrp_free(struct gfs2_sbd *sdp, struct osi_root *rgrp_tree)
+void lgfs2_rgrp_free(struct gfs2_sbd *sdp, struct osi_root *rgrp_tree)
{
struct rgrp_tree *rgd;
struct osi_node *n;
@@ -289,7 +289,7 @@ void gfs2_rgrp_free(struct gfs2_sbd *sdp, struct osi_root
*rgrp_tree)
while ((n = osi_first(rgrp_tree))) {
rgd = (struct rgrp_tree *)n;
- gfs2_rgrp_relse(sdp, rgd);
+ lgfs2_rgrp_relse(sdp, rgd);
free(rgd->bits);
rgd->bits = NULL;
osi_erase(&rgd->node, rgrp_tree);
@@ -523,7 +523,7 @@ void lgfs2_rgrps_free(lgfs2_rgrps_t *rgs)
* needed for bitmaps. Also calculate the adjusted number of free data blocks
* in the resource group and store it in *ri_data.
*/
-uint32_t rgblocks2bitblocks(const unsigned int bsize, const uint32_t rgblocks,
uint32_t *ri_data)
+uint32_t lgfs2_rgblocks2bitblocks(const unsigned int bsize, const uint32_t
rgblocks, uint32_t *ri_data)
{
uint32_t mappable = 0;
uint32_t bitblocks = 0;
@@ -579,7 +579,7 @@ uint64_t lgfs2_rindex_entry_new(lgfs2_rgrps_t rgs, struct
gfs2_rindex *ri, uint6
if (addr + len > rgs->sdp->device.length)
return 0;
- ri_length = rgblocks2bitblocks(rgs->sdp->sd_bsize, len, &ri_data);
+ ri_length = lgfs2_rgblocks2bitblocks(rgs->sdp->sd_bsize, len, &ri_data);
ri->ri_addr = cpu_to_be64(addr);
ri->ri_length = cpu_to_be32(ri_length);
ri->ri_data = cpu_to_be32(ri_data);
diff --git a/gfs2/libgfs2/super.c b/gfs2/libgfs2/super.c
index 15f89a30..da605ded 100644
--- a/gfs2/libgfs2/super.c
+++ b/gfs2/libgfs2/super.c
@@ -228,7 +228,7 @@ int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount,
int *ok)
continue;
addr = prev_rgd->rt_data0 + prev_rgd->rt_data;
}
- rgd = rgrp_insert(&sdp->rgtree, addr);
+ rgd = lgfs2_rgrp_insert(&sdp->rgtree, addr);
rgd->rt_length = be32_to_cpu(ri.ri_length);
rgd->rt_data0 = be64_to_cpu(ri.ri_data0);
rgd->rt_data = be32_to_cpu(ri.ri_data);
@@ -248,7 +248,7 @@ int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount,
int *ok)
prev_length = rgd->rt_addr - prev_rgd->rt_addr;
}
- if(gfs2_compute_bitstructs(sdp->sd_bsize, rgd))
+ if(lgfs2_compute_bitstructs(sdp->sd_bsize, rgd))
*ok = 0;
(*rgcount)++;
--
2.34.1
