This is an automated email from the git hooks/post-receive script.
andyp pushed a commit to branch andyp-sparse
in repository gfs2-utils.
commit d8a351b18dc5947b11a355628d44fb8d409ec0d1
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Wed May 19 19:26:18 2021 +0100
libgfs2: Remove big-endian structs from struct rgrp_tree
Replace them with native-endian fields that combine the struct
gfs2_rindex, struct gfs2_rgrp and struct gfs_rgrp. Some fields (e.g.
rg_crc) are omitted because they are unneeded other than when the struct
is read and written. This reduces the memory usage of the resource group
tree in the utils. Convert the relevant gfs2_(struct)_in/out() functions
to use the new fields.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/convert/gfs2_convert.c | 83 ++++++++-----------
gfs2/edit/extended.c | 25 +++---
gfs2/edit/hexedit.c | 56 ++++++-------
gfs2/edit/journal.c | 10 +--
gfs2/edit/savemeta.c | 23 ++----
gfs2/fsck/fs_recovery.c | 14 ++--
gfs2/fsck/fsck.h | 4 +-
gfs2/fsck/initialize.c | 102 ++++++++++-------------
gfs2/fsck/main.c | 8 +-
gfs2/fsck/metawalk.c | 24 +++---
gfs2/fsck/pass1.c | 9 +-
gfs2/fsck/pass5.c | 59 ++++++-------
gfs2/fsck/rgrepair.c | 197 ++++++++++++++++++++------------------------
gfs2/fsck/util.c | 10 +--
gfs2/libgfs2/check_rgrp.c | 27 +++---
gfs2/libgfs2/fs_bits.c | 10 +--
gfs2/libgfs2/fs_ops.c | 38 ++++-----
gfs2/libgfs2/gfs1.c | 32 +++++++
gfs2/libgfs2/lang.c | 2 +-
gfs2/libgfs2/libgfs2.h | 53 +++++++++---
gfs2/libgfs2/ondisk.c | 103 +++++++++++------------
gfs2/libgfs2/rgrp.c | 159 ++++++++++++++++-------------------
gfs2/libgfs2/rgrp.h | 2 +-
gfs2/libgfs2/structures.c | 4 +-
gfs2/libgfs2/super.c | 35 ++++----
gfs2/mkfs/main_grow.c | 9 +-
gfs2/mkfs/main_mkfs.c | 25 ++++--
tests/nukerg.c | 11 +--
28 files changed, 547 insertions(+), 587 deletions(-)
diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c
index d1cccd59..280eac42 100644
--- a/gfs2/convert/gfs2_convert.c
+++ b/gfs2/convert/gfs2_convert.c
@@ -135,11 +135,9 @@ static void convert_bitmaps(struct gfs2_sbd *sdp, struct rgrp_tree
*rg)
{
uint32_t blk;
int x, y;
- struct gfs2_rindex *ri;
unsigned char state;
- ri = &rg->ri;
- for (blk = 0; blk < ri->ri_length; blk++) {
+ for (blk = 0; blk < rg->rt_length; blk++) {
struct gfs2_bitmap *bi;
x = (blk) ? sizeof(struct gfs2_meta_header) :
sizeof(struct gfs2_rgrp);
@@ -164,7 +162,6 @@ static int convert_rgs(struct gfs2_sbd *sbp)
{
struct rgrp_tree *rgd;
struct osi_node *n, *next = NULL;
- struct gfs_rgrp *rgd1;
int rgs = 0;
/* --------------------------------- */
@@ -174,20 +171,17 @@ static int convert_rgs(struct gfs2_sbd *sbp)
next = osi_next(n);
rgd = (struct rgrp_tree *)n;
- rgd1 = (struct gfs_rgrp *)&rgd->rg; /* recast as gfs1 structure */
- /* rg_freemeta is a gfs1 structure, so libgfs2 doesn't know to */
- /* convert from be to cpu. We must do it now. */
- rgd->rg.rg_free = rgd1->rg_free + be32_to_cpu(rgd1->rg_freemeta);
+ rgd->rt_free = rgd->rt_free + rgd->rt_freemeta;
/* Zero it out so we don't add it again in case something breaks */
/* later on in the process and we have to re-run convert */
- rgd1->rg_freemeta = 0;
+ rgd->rt_freemeta = 0;
- sbp->blks_total += rgd->ri.ri_data;
- sbp->blks_alloced += (rgd->ri.ri_data - rgd->rg.rg_free);
- sbp->dinodes_alloced += rgd1->rg_useddi;
+ sbp->blks_total += rgd->rt_data;
+ sbp->blks_alloced += (rgd->rt_data - rgd->rt_free);
+ sbp->dinodes_alloced += rgd->rt_useddi;
convert_bitmaps(sbp, rgd);
/* Write the updated rgrp to the gfs2 buffer */
- gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_rgrp_out(rgd, rgd->bits[0].bi_data);
rgd->bits[0].bi_modified = 1;
rgs++;
if (rgs % 100 == 0) {
@@ -967,11 +961,11 @@ err_freei:
static int next_rg_meta(struct rgrp_tree *rgd, uint64_t *block, int first)
{
struct gfs2_bitmap *bits = NULL;
- uint32_t length = rgd->ri.ri_length;
- uint32_t blk = (first)? 0: (uint32_t)((*block + 1) - rgd->ri.ri_data0);
+ uint32_t length = rgd->rt_length;
+ uint32_t blk = (first)? 0: (uint32_t)((*block + 1) - rgd->rt_data0);
int i;
- if (!first && (*block < rgd->ri.ri_data0)) {
+ if (!first && (*block < rgd->rt_data0)) {
fprintf(stderr, "next_rg_meta: Start block is outside rgrp bounds.\n");
exit(1);
}
@@ -986,8 +980,7 @@ static int next_rg_meta(struct rgrp_tree *rgd, uint64_t *block, int
first)
blk = gfs2_bitfit((uint8_t *)bits->bi_data + bits->bi_offset,
bits->bi_len, blk, GFS2_BLKST_DINODE);
if(blk != BFITNOENT){
- *block = blk + (bits->bi_start * GFS2_NBBY) +
- rgd->ri.ri_data0;
+ *block = blk + (bits->bi_start * GFS2_NBBY) + rgd->rt_data0;
break;
}
blk = 0;
@@ -1083,10 +1076,10 @@ static int inode_renumber(struct gfs2_sbd *sbp, uint64_t
root_inode_addr, osi_li
/* Figure out the absolute bitmap byte we need to fix. */
/* ignoring structure offsets and bitmap blocks for now. */
- bitmap_byte = (block - rgd->ri.ri_data0) / GFS2_NBBY;
- byte_bit = (block - rgd->ri.ri_data0) % GFS2_NBBY;
+ bitmap_byte = (block - rgd->rt_data0) / GFS2_NBBY;
+ byte_bit = (block - rgd->rt_data0) % GFS2_NBBY;
/* Now figure out which bitmap block the byte is on */
- for (blk = 0; blk < rgd->ri.ri_length; blk++) {
+ for (blk = 0; blk < rgd->rt_length; blk++) {
struct gfs2_bitmap *bi = &rgd->bits[blk];
/* figure out offset of first bitmap byte for this map: */
buf_offset = (blk) ? sizeof(struct gfs2_meta_header) :
@@ -1551,7 +1544,6 @@ static int sanity_check(struct gfs2_sbd *sdp)
static int gfs1_ri_update(struct gfs2_sbd *sdp, int *rgcount, int quiet)
{
struct rgrp_tree *rgd;
- struct gfs2_rindex *ri;
uint64_t count1 = 0, count2 = 0;
uint64_t errblock = 0;
uint64_t rmax = 0;
@@ -1572,9 +1564,8 @@ static int gfs1_ri_update(struct gfs2_sbd *sdp, int *rgcount, int
quiet)
printf(".");
fflush(stdout);
}
- ri = &rgd->ri;
- if (ri->ri_data0 + ri->ri_data - 1 > rmax)
- rmax = ri->ri_data0 + ri->ri_data - 1;
+ if (rgd->rt_data0 + rgd->rt_data - 1 > rmax)
+ rmax = rgd->rt_data0 + rgd->rt_data - 1;
}
sdp->fssize = rmax;
@@ -1878,60 +1869,56 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
for (n = osi_first(&sdp->rgtree); n; n = next) {
next = osi_next(n);
rgd = (struct rgrp_tree *)n;
- if (rgd->ri.ri_addr < jndx->ji_addr &&
+ if (rgd->rt_addr < jndx->ji_addr &&
((rgdhigh == NULL) ||
- (rgd->ri.ri_addr > rgdhigh->ri.ri_addr)))
+ (rgd->rt_addr > rgdhigh->rt_addr)))
rgdhigh = rgd;
} /* for each rg */
if (!rgdhigh) { /* if we somehow didn't find one. */
log_crit(_("Error: No suitable rg found for journal.\n"));
return -1;
}
- log_info(_("Addr 0x%llx comes after rg at addr 0x%llx\n"),
- (unsigned long long)jndx->ji_addr,
- (unsigned long long)rgdhigh->ri.ri_addr);
+ log_info(_("Addr 0x%"PRIx64" comes after rg at addr
0x%"PRIx64"\n"),
+ jndx->ji_addr, rgdhigh->rt_addr);
ri_addr = jndx->ji_addr;
/* Allocate a new rgd entry which includes rg and ri. */
rgd = rgrp_insert(&sdp->rgtree, ri_addr);
/* convert the gfs1 rgrp into a new gfs2 rgrp */
size = jndx->ji_nsegment *
be32_to_cpu(raw_gfs1_ondisk_sb.sb_seg_size);
- rgd->rg.rg_header.mh_magic = GFS2_MAGIC;
- rgd->rg.rg_header.mh_type = GFS2_METATYPE_RG;
- rgd->rg.rg_header.mh_format = GFS2_FORMAT_RG;
- rgd->rg.rg_flags = 0;
- rgd->rg.rg_dinodes = 0;
+ rgd->rt_flags = 0;
+ rgd->rt_dinodes = 0;
- rgd->ri.ri_addr = jndx->ji_addr; /* new rg addr becomes ji addr */
- rgd->ri.ri_length = rgrp_length(size, sdp); /* aka bitblocks */
+ rgd->rt_addr = jndx->ji_addr; /* new rg addr becomes ji addr */
+ rgd->rt_length = rgrp_length(size, sdp); /* aka bitblocks */
- rgd->ri.ri_data0 = jndx->ji_addr + rgd->ri.ri_length;
- rgd->ri.ri_data = size - rgd->ri.ri_length;
+ rgd->rt_data0 = jndx->ji_addr + rgd->rt_length;
+ rgd->rt_data = size - rgd->rt_length;
/* Round down to nearest multiple of GFS2_NBBY */
- while (rgd->ri.ri_data & 0x03)
- rgd->ri.ri_data--;
- sdp->blks_total += rgd->ri.ri_data; /* For statfs file update */
- rgd->rg.rg_free = rgd->ri.ri_data;
- rgd->ri.ri_bitbytes = rgd->ri.ri_data / GFS2_NBBY;
+ while (rgd->rt_data & 0x03)
+ rgd->rt_data--;
+ sdp->blks_total += rgd->rt_data; /* For statfs file update */
+ rgd->rt_free = rgd->rt_data;
+ rgd->rt_bitbytes = rgd->rt_data / GFS2_NBBY;
if (gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, rgd)) {
log_crit(_("gfs2_convert: Error converting bitmaps.\n"));
exit(-1);
}
- rgd->bits[0].bi_data = calloc(rgd->ri.ri_length, sdp->bsize);
+ rgd->bits[0].bi_data = calloc(rgd->rt_length, sdp->bsize);
if (rgd->bits[0].bi_data == NULL) {
perror("");
exit(-1);
}
- for (unsigned i = 1; i < rgd->ri.ri_length; i++)
+ for (unsigned i = 1; i < rgd->rt_length; i++)
rgd->bits[i].bi_data = rgd->bits[0].bi_data + (i * sdp->bsize);
convert_bitmaps(sdp, rgd);
- gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_rgrp_out(rgd, rgd->bits[0].bi_data);
rgd->bits[0].bi_modified = 1;
- for (unsigned i = 1; i < rgd->ri.ri_length; i++) {
+ for (unsigned i = 1; i < rgd->rt_length; i++) {
gfs2_meta_header_out(&mh, rgd->bits[i].bi_data);
rgd->bits[i].bi_modified = 1;
}
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index f3b1bba0..e9e2a7eb 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -503,8 +503,8 @@ static int parse_rindex(struct gfs2_inode *dip, int print_rindex)
{
int error, start_line;
struct gfs2_rindex ri;
- char rbuf[sizeof(struct gfs2_rindex)];
char highlighted_addr[32];
+ struct rgrp_tree rg = {0};
start_line = line;
print_gfs2("RG index entries found: %"PRIu64".",
@@ -518,39 +518,38 @@ static int parse_rindex(struct gfs2_inode *dip, int print_rindex)
roff = print_entry_ndx * sizeof(struct gfs2_rindex);
- error = gfs2_readi(dip, (void *)&rbuf, roff,
- sizeof(struct gfs2_rindex));
+ error = gfs2_readi(dip, &ri, roff, sizeof(struct gfs2_rindex));
if (!error) /* end of file */
break;
- gfs2_rindex_in(&ri, rbuf);
+ lgfs2_rindex_in(&rg, &ri);
if (!termlines ||
(print_entry_ndx >= start_row[dmode] &&
((print_entry_ndx - start_row[dmode])+1) * lines_per_row[dmode] <=
termlines - start_line - 2)) {
if (edit_row[dmode] == print_entry_ndx) {
COLORS_HIGHLIGHT;
- sprintf(highlighted_addr, "%"PRIx64, ri.ri_addr);
+ sprintf(highlighted_addr, "%"PRIx64, rg.rt_addr);
}
print_gfs2("RG #%d", print_entry_ndx);
if (!print_rindex)
print_gfs2(" located at: %"PRIu64" (0x%"PRIx64")",
- ri.ri_addr, ri.ri_addr);
+ rg.rt_addr, rg.rt_addr);
eol(0);
if (edit_row[dmode] == print_entry_ndx)
COLORS_NORMAL;
- if(print_rindex)
- gfs2_rindex_print(&ri);
+ if (print_rindex)
+ lgfs2_rindex_print(&ri);
else {
- char buf[sizeof(struct gfs2_rgrp)] = {0};
+ struct gfs2_rgrp r = {0};
ssize_t ret;
- ret = pread(sbd.device_fd, buf, sizeof(buf), ri.ri_addr * sbd.bsize);
- if (ret != sizeof(buf)) {
+ ret = pread(sbd.device_fd, &r, sizeof(r), rg.rt_addr * sbd.bsize);
+ if (ret != sizeof(r)) {
perror("Failed to read resource group");
} else if (sbd.gfs1) {
- gfs_rgrp_print(buf);
+ gfs_rgrp_print(&r);
} else {
- lgfs2_rgrp_print(buf);
+ lgfs2_rgrp_print(&r);
}
}
last_entry_onscreen[dmode] = print_entry_ndx;
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index 4fbe071d..18afd0ed 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -390,7 +390,7 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
blknum = pgnum * screen_chunk_size;
blknum += (ptroffset - struct_len);
blknum *= 4;
- blknum += rgd->ri.ri_data0;
+ blknum += rgd->rt_data0;
print_gfs2(" blk ");
for (b = blknum; b < blknum + 4; b++) {
@@ -407,7 +407,7 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
if (rgd && (ptroffset >= struct_len || pgnum)) {
int blknum, b, btype, rb_number;
- rb_number = block - rgd->ri.ri_addr;
+ rb_number = block - rgd->rt_addr;
blknum = 0;
/* count the number of bytes representing
blocks prior to the displayed screen. */
@@ -425,7 +425,7 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
/* convert bytes to blocks */
blknum *= GFS2_NBBY;
/* add the starting offset for this rgrp */
- blknum += rgd->ri.ri_data0;
+ blknum += rgd->rt_data0;
print_gfs2(" blk ");
for (b = blknum; b < blknum + 4; b++) {
btype = lgfs2_get_bitmap(&sbd, b, rgd);
@@ -709,7 +709,7 @@ static void rgcount(void)
static uint64_t find_rgrp_block(struct gfs2_inode *dif, int rg)
{
int amt;
- struct gfs2_rindex fbuf, ri;
+ struct gfs2_rindex ri;
uint64_t foffset, gfs1_adj = 0;
foffset = rg * sizeof(struct gfs2_rindex);
@@ -721,12 +721,10 @@ static uint64_t find_rgrp_block(struct gfs2_inode *dif, int rg)
sizeof(struct gfs2_meta_header);
gfs1_adj += sizeof(struct gfs2_meta_header);
}
- amt = gfs2_readi(dif, (void *)&fbuf, foffset + gfs1_adj,
- sizeof(struct gfs2_rindex));
+ amt = gfs2_readi(dif, &ri, foffset + gfs1_adj, sizeof(ri));
if (!amt) /* end of file */
return 0;
- gfs2_rindex_in(&ri, (void *)&fbuf);
- return ri.ri_addr;
+ return be64_to_cpu(ri.ri_addr);
}
/* ------------------------------------------------------------------------ */
@@ -964,7 +962,6 @@ static void read_superblock(int fd)
static int read_rindex(void)
{
- struct gfs2_rindex *ri;
uint64_t count;
int ok;
@@ -973,8 +970,8 @@ static int read_rindex(void)
rindex_read(&sbd, &count, &ok);
if (!OSI_EMPTY_ROOT(&sbd.rgtree)) {
- ri = &((struct rgrp_tree *)osi_last(&sbd.rgtree))->ri;
- sbd.fssize = ri->ri_data0 + ri->ri_data;
+ struct rgrp_tree *rg = (struct rgrp_tree *)osi_last(&sbd.rgtree);
+ sbd.fssize = rg->rt_data0 + rg->rt_data;
}
return 0;
}
@@ -1202,7 +1199,7 @@ static int find_rg_metatype(struct rgrp_tree *rgd, uint64_t *blk,
uint64_t start
struct gfs2_buffer_head *bhp = NULL;
uint64_t *ibuf = malloc(sbd.bsize * GFS2_NBBY * sizeof(uint64_t));
- for (i = 0; i < rgd->ri.ri_length; i++) {
+ for (i = 0; i < rgd->rt_length; i++) {
m = lgfs2_bm_scan(rgd, i, ibuf, GFS2_BLKST_DINODE);
for (j = 0; j < m; j++) {
@@ -1233,18 +1230,16 @@ static uint64_t find_metablockoftype_rg(uint64_t startblk, int
metatype, int pri
uint64_t blk, errblk;
int first = 1, found = 0;
struct rgrp_tree *rgd = NULL;
- struct gfs2_rindex *ri;
blk = 0;
/* Skip the rgs prior to the block we've been given */
for (next = osi_first(&sbd.rgtree); next; next = osi_next(next)) {
rgd = (struct rgrp_tree *)next;
- ri = &rgd->ri;
- if (first && startblk <= ri->ri_data0) {
- startblk = ri->ri_data0;
+ if (first && startblk <= rgd->rt_data0) {
+ startblk = rgd->rt_data0;
break;
- } else if (ri->ri_addr <= startblk &&
- startblk < ri->ri_data0 + ri->ri_data)
+ } else if (rgd->rt_addr <= startblk &&
+ startblk < rgd->rt_data0 + rgd->rt_data)
break;
else
rgd = NULL;
@@ -1644,19 +1639,19 @@ static void find_print_block_rg(int bitmap)
else {
rgd = gfs2_blk2rgrpd(&sbd, rblock);
if (rgd) {
- rgblock = rgd->ri.ri_addr;
+ rgblock = rgd->rt_addr;
if (bitmap) {
struct gfs2_bitmap *bits = NULL;
- for (i = 0; i < rgd->ri.ri_length; i++) {
+ for (i = 0; i < rgd->rt_length; i++) {
bits = &(rgd->bits[i]);
- if (rblock - rgd->ri.ri_data0 <
+ if (rblock - rgd->rt_data0 <
((bits->bi_start + bits->bi_len) *
GFS2_NBBY)) {
break;
}
}
- if (i < rgd->ri.ri_length)
+ if (i < rgd->rt_length)
rgblock += i;
}
@@ -2183,7 +2178,7 @@ static int count_dinode_blks(struct rgrp_tree *rgd, int bitmap,
off = sizeof(struct gfs2_rgrp);
for (b = 0; b < rgd->bits[bitmap].bi_len << GFS2_BIT_SIZE; b++) {
- tbh = bread(&sbd, rgd->ri.ri_data0 +
+ tbh = bread(&sbd, rgd->rt_data0 +
rgd->bits[bitmap].bi_start + b);
byte = rbh->b_data + off + (b / GFS2_NBBY);
bit = (b % GFS2_NBBY) * GFS2_BIT_SIZE;
@@ -2247,17 +2242,16 @@ static void rg_repair(void)
repaired bitmap to GFS2_BLKST_DINODE. Set all others to
GFS2_BLKST_USED so fsck can sort it out. If we set them
to FREE, fsck would just nuke it all. */
- printf("Resource group at block %llu (0x%llx) appears to be "
+ printf("Resource group at block %"PRIu64" (0x%"PRIx64")
appears to be "
"damaged. Attempting to fix it (in reverse order).\n",
- (unsigned long long)rgd->ri.ri_addr,
- (unsigned long long)rgd->ri.ri_addr);
+ rgd->rt_addr, rgd->rt_addr);
- for (b = rgd->ri.ri_length - 1; b >= 0; b--) {
+ for (b = rgd->rt_length - 1; b >= 0; b--) {
int mtype = (b ? GFS2_METATYPE_RB : GFS2_METATYPE_RG);
struct gfs2_meta_header *mh;
printf("Bitmap #%d:", b);
- rbh = bread(&sbd, rgd->ri.ri_addr + b);
+ rbh = bread(&sbd, rgd->rt_addr + b);
if (gfs2_check_meta(rbh->b_data, mtype)) { /* wrong type */
printf("Damaged. Repairing...");
/* Fix the meta header */
@@ -2281,8 +2275,8 @@ static void rg_repair(void)
printf("Dinodes found: %d\n", dinodes_found);
dinodes_total += dinodes_found;
if (b == 0) { /* rgrp itself was damaged */
- rgd->rg.rg_dinodes = dinodes_total;
- rgd->rg.rg_free = 0;
+ rgd->rt_dinodes = dinodes_total;
+ rgd->rt_free = 0;
}
brelse(rbh);
}
@@ -2521,7 +2515,7 @@ static void process_parameters(int argc, char *argv[], int pass)
gfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_FAILURE);
}
- for (bmap = 0; bmap < rgd->ri.ri_length; bmap++)
+ for (bmap = 0; bmap < rgd->rt_length; bmap++)
push_block(rgblk + bmap);
}
else if (!strcmp(argv[i], "rgrepair"))
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index 13b8c121..0da00235 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -255,7 +255,7 @@ static int print_ld_blks(const uint64_t *b, const char *end, int
start_line,
found_bblk = 1;
print_gfs2("<-------------------------");
if (is_meta_ld) {
- o = tblk - rgd->ri.ri_data0;
+ o = tblk - rgd->rt_data0;
if (o >= (rgd->bits->bi_start +
rgd->bits->bi_len) *
GFS2_NBBY)
@@ -563,16 +563,16 @@ void dump_journal(const char *journal, int tblk)
uint64_t o;
int bmap = 0;
- print_gfs2("rgd: 0x%"PRIx64" for 0x%"PRIx32", ",
rgd->ri.ri_addr,
- rgd->ri.ri_length);
- o = tblk - rgd->ri.ri_data0;
+ print_gfs2("rgd: 0x%"PRIx64" for 0x%"PRIx32", ",
rgd->rt_addr,
+ rgd->rt_length);
+ o = tblk - rgd->rt_data0;
if (o >= (rgd->bits->bi_start +
rgd->bits->bi_len) * (uint64_t)GFS2_NBBY)
o += (sizeof(struct gfs2_rgrp) -
sizeof(struct gfs2_meta_header))
* GFS2_NBBY;
bmap = o / sbd.sd_blocks_per_bitmap;
- bitblk = rgd->ri.ri_addr + bmap;
+ bitblk = rgd->rt_addr + bmap;
print_gfs2("bitmap: %d, bitblk: 0x%"PRIx64, bmap, bitblk);
eol(0);
}
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 9c003e68..e55b66f6 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -994,7 +994,7 @@ static void save_allocated(struct rgrp_tree *rgd, struct metafd *mfd)
unsigned i, j, m;
uint64_t *ibuf = malloc(sbd.bsize * GFS2_NBBY * sizeof(uint64_t));
- for (i = 0; i < rgd->ri.ri_length; i++) {
+ for (i = 0; i < rgd->rt_length; i++) {
struct block_range br = {0};
m = lgfs2_bm_scan(rgd, i, ibuf, GFS2_BLKST_DINODE);
@@ -1056,33 +1056,28 @@ static char *rgrp_read(struct gfs2_sbd *sdp, uint64_t addr,
unsigned blocks)
static void save_rgrp(struct gfs2_sbd *sdp, struct metafd *mfd, struct rgrp_tree *rgd,
int withcontents)
{
- uint64_t addr = rgd->ri.ri_addr;
+ uint64_t addr = rgd->rt_addr;
char *buf;
- buf = rgrp_read(sdp, rgd->ri.ri_addr, rgd->ri.ri_length);
+ buf = rgrp_read(sdp, rgd->rt_addr, rgd->rt_length);
if (buf == NULL)
return;
- if (sdp->gfs1)
- gfs_rgrp_in((struct gfs_rgrp *)&rgd->rg, buf);
- else
- gfs2_rgrp_in(&rgd->rg, buf);
-
- for (unsigned i = 0; i < rgd->ri.ri_length; i++)
+ for (unsigned i = 0; i < rgd->rt_length; i++)
rgd->bits[i].bi_data = buf + (i * sdp->bsize);
- log_debug("RG at %"PRIu64" is %"PRIu32" long\n", addr,
(uint32_t)rgd->ri.ri_length);
+ log_debug("RG at %"PRIu64" is %"PRIu32" long\n", addr,
rgd->rt_length);
/* Save the rg and bitmaps */
- for (unsigned i = 0; i < rgd->ri.ri_length; i++) {
- report_progress(rgd->ri.ri_addr + i, 0);
- save_buf(mfd, buf + (i * sdp->bsize), rgd->ri.ri_addr + i, sdp->bsize);
+ for (unsigned i = 0; i < rgd->rt_length; i++) {
+ report_progress(rgd->rt_addr + i, 0);
+ save_buf(mfd, buf + (i * sdp->bsize), rgd->rt_addr + i, sdp->bsize);
}
/* Save the other metadata: inodes, etc. if mode is not 'savergs' */
if (withcontents)
save_allocated(rgd, mfd);
free(buf);
- for (unsigned i = 0; i < rgd->ri.ri_length; i++)
+ for (unsigned i = 0; i < rgd->rt_length; i++)
rgd->bits[i].bi_data = NULL;
}
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index e481c88a..61b37b75 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -101,19 +101,19 @@ static void refresh_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree
*rgd,
{
int i;
- log_debug(_("Block is part of rgrp 0x%llx; refreshing the rgrp.\n"),
- (unsigned long long)rgd->ri.ri_addr);
- for (i = 0; i < rgd->ri.ri_length; i++) {
- if (rgd->ri.ri_addr + i != blkno)
+ log_debug(_("Block is part of rgrp 0x%"PRIx64"; refreshing the
rgrp.\n"),
+ rgd->rt_addr);
+ for (i = 0; i < rgd->rt_length; i++) {
+ if (rgd->rt_addr + i != blkno)
continue;
memcpy(rgd->bits[i].bi_data, bh->b_data, sdp->bsize);
rgd->bits[i].bi_modified = 1;
if (i == 0) { /* this is the rgrp itself */
if (sdp->gfs1)
- gfs_rgrp_in((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_gfs_rgrp_in(rgd, rgd->bits[0].bi_data);
else
- gfs2_rgrp_in(&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_rgrp_in(rgd, rgd->bits[0].bi_data);
}
break;
}
@@ -172,7 +172,7 @@ static int buf_lo_scan_elements(struct gfs2_inode *ip, unsigned int
start,
} else {
bmodified(bh_ip);
rgd = gfs2_blk2rgrpd(sdp, blkno);
- if (rgd && blkno < rgd->ri.ri_data0)
+ 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 16aab67d..8b7ac0a9 100644
--- a/gfs2/fsck/fsck.h
+++ b/gfs2/fsck/fsck.h
@@ -167,9 +167,9 @@ static inline int valid_block(struct gfs2_sbd *sdp, uint64_t blkno)
static inline int rgrp_contains_block(struct rgrp_tree *rgd, uint64_t blk)
{
- if (blk < rgd->ri.ri_addr)
+ if (blk < rgd->rt_addr)
return 0;
- if (blk >= rgd->ri.ri_data0 + rgd->ri.ri_data)
+ if (blk >= rgd->rt_data0 + rgd->rt_data)
return 0;
return 1;
}
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 3f2c088b..16cc1b49 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -134,7 +134,6 @@ static int set_block_ranges(struct gfs2_sbd *sdp)
{
struct osi_node *n, *next = NULL;
struct rgrp_tree *rgd;
- struct gfs2_rindex *ri;
char buf[sdp->sd_sb.sb_bsize];
uint64_t rmax = 0;
uint64_t rmin = 0;
@@ -145,12 +144,11 @@ static int set_block_ranges(struct gfs2_sbd *sdp)
for (n = osi_first(&sdp->rgtree); n; n = next) {
next = osi_next(n);
rgd = (struct rgrp_tree *)n;
- ri = &rgd->ri;
- if (ri->ri_data0 + ri->ri_data &&
- ri->ri_data0 + ri->ri_data - 1 > rmax)
- rmax = ri->ri_data0 + ri->ri_data - 1;
- if (!rmin || ri->ri_data0 < rmin)
- rmin = ri->ri_data0;
+ if (rgd->rt_data0 + rgd->rt_data &&
+ rgd->rt_data0 + rgd->rt_data - 1 > rmax)
+ rmax = rgd->rt_data0 + rgd->rt_data - 1;
+ if (!rmin || rgd->rt_data0 < rmin)
+ rmin = rgd->rt_data0;
}
last_fs_block = rmax;
@@ -201,17 +199,16 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
uint32_t rg_free, rg_reclaimed, rg_unlinked, rg_usedmeta, rg_useddi;
int rgb, x, y, off, bytes_to_check, total_bytes_to_check, asked = 0;
unsigned int state;
- struct gfs_rgrp *gfs1rg = (struct gfs_rgrp *)&rgd->rg;
uint64_t diblock;
struct gfs2_buffer_head *bh;
rg_free = rg_reclaimed = rg_unlinked = rg_usedmeta = rg_useddi = 0;
- total_bytes_to_check = rgd->ri.ri_bitbytes;
+ total_bytes_to_check = rgd->rt_bitbytes;
*this_rg_fixed = *this_rg_bad = *this_rg_cleaned = 0;
- diblock = rgd->ri.ri_data0;
- for (rgb = 0; rgb < rgd->ri.ri_length; rgb++){
+ diblock = rgd->rt_data0;
+ for (rgb = 0; rgb < rgd->rt_length; rgb++){
/* Count up the free blocks in the bitmap */
off = (rgb) ? sizeof(struct gfs2_meta_header) :
sizeof(struct gfs2_rgrp);
@@ -274,9 +271,8 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
sprintf(msg,
_("Okay to reclaim free "
"metadata in resource group "
- "%lld (0x%llx)? (y/n)"),
- (unsigned long long)rgd->ri.ri_addr,
- (unsigned long long)rgd->ri.ri_addr);
+ "%"PRIu64" (0x%"PRIx64")? (y/n)"),
+ rgd->rt_addr, rgd->rt_addr);
if (query("%s", msg))
*fixit = 1;
}
@@ -290,9 +286,9 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
rgd->bits[rgb].bi_modified = 1;
rg_reclaimed++;
rg_free++;
- rgd->rg.rg_free++;
- if (sdp->gfs1 && gfs1rg->rg_freemeta)
- gfs1rg->rg_freemeta--;
+ rgd->rt_free++;
+ if (sdp->gfs1 && rgd->rt_freemeta)
+ rgd->rt_freemeta--;
log_info(_("Free metadata block %lld (0x%llx) "
"reclaimed.\n"),
(unsigned long long)diblock,
@@ -323,31 +319,27 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
will be reported. */
if (rg_reclaimed && *fixit) {
if (sdp->gfs1)
- gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_gfs_rgrp_out(rgd, rgd->bits[0].bi_data);
else
- gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_rgrp_out(rgd, rgd->bits[0].bi_data);
rgd->bits[0].bi_modified = 1;
*this_rg_cleaned = 1;
- log_info( _("The rgrp at %lld (0x%llx) was cleaned of %d "
+ log_info(_("The rgrp at %"PRIu64" (0x%"PRIx64") was cleaned of
%d "
"free metadata blocks.\n"),
- (unsigned long long)rgd->ri.ri_addr,
- (unsigned long long)rgd->ri.ri_addr,
- rg_reclaimed);
+ rgd->rt_addr, rgd->rt_addr, rg_reclaimed);
}
- if (rgd->rg.rg_free != rg_free) {
+ if (rgd->rt_free != rg_free) {
*this_rg_bad = 1;
*this_rg_cleaned = 0;
- log_err( _("Error: resource group %lld (0x%llx): "
+ log_err( _("Error: resource group %"PRIu64" (0x%"PRIx64"):
"
"free space (%d) does not match bitmap (%d)\n"),
- (unsigned long long)rgd->ri.ri_addr,
- (unsigned long long)rgd->ri.ri_addr,
- rgd->rg.rg_free, rg_free);
+ rgd->rt_addr, rgd->rt_addr, rgd->rt_free, rg_free);
if (query( _("Fix the rgrp free blocks count? (y/n)"))) {
- rgd->rg.rg_free = rg_free;
+ rgd->rt_free = rg_free;
if (sdp->gfs1)
- gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_gfs_rgrp_out(rgd, rgd->bits[0].bi_data);
else
- gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_rgrp_out(rgd, rgd->bits[0].bi_data);
rgd->bits[0].bi_modified = 1;
*this_rg_fixed = 1;
log_err( _("The rgrp was fixed.\n"));
@@ -357,51 +349,45 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
if (!sdp->gfs1)
return;
- if (gfs1rg->rg_freemeta != rg_unlinked) {
+ if (rgd->rt_freemeta != rg_unlinked) {
*this_rg_bad = 1;
*this_rg_cleaned = 0;
- log_err( _("Error: resource group %lld (0x%llx): "
- "free meta (%d) does not match bitmap (%d)\n"),
- (unsigned long long)rgd->ri.ri_addr,
- (unsigned long long)rgd->ri.ri_addr,
- gfs1rg->rg_freemeta, rg_unlinked);
+ log_err(_("Error: resource group %"PRIu64" (0x%"PRIx64"):
"
+ "free meta (%d) does not match bitmap (%d)\n"),
+ rgd->rt_addr, rgd->rt_addr, rgd->rt_freemeta, rg_unlinked);
if (query( _("Fix the rgrp free meta blocks count? (y/n)"))) {
- gfs1rg->rg_freemeta = rg_unlinked;
- gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+ rgd->rt_freemeta = rg_unlinked;
+ lgfs2_gfs_rgrp_out(rgd, rgd->bits[0].bi_data);
rgd->bits[0].bi_modified = 1;
*this_rg_fixed = 1;
log_err( _("The rgrp was fixed.\n"));
} else
log_err( _("The rgrp was not fixed.\n"));
}
- if (gfs1rg->rg_useddi != rg_useddi) {
+ if (rgd->rt_useddi != rg_useddi) {
*this_rg_bad = 1;
*this_rg_cleaned = 0;
- log_err( _("Error: resource group %lld (0x%llx): used dinode "
+ log_err(_("Error: resource group %"PRIu64" (0x%"PRIx64"): used
dinode "
"count (%d) does not match bitmap (%d)\n"),
- (unsigned long long)rgd->ri.ri_addr,
- (unsigned long long)rgd->ri.ri_addr,
- gfs1rg->rg_useddi, rg_useddi);
+ rgd->rt_addr, rgd->rt_addr, rgd->rt_useddi, rg_useddi);
if (query( _("Fix the rgrp used dinode block count? (y/n)"))) {
- gfs1rg->rg_useddi = rg_useddi;
- gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+ rgd->rt_useddi = rg_useddi;
+ lgfs2_gfs_rgrp_out(rgd, rgd->bits[0].bi_data);
rgd->bits[0].bi_modified = 1;
*this_rg_fixed = 1;
log_err( _("The rgrp was fixed.\n"));
} else
log_err( _("The rgrp was not fixed.\n"));
}
- if (gfs1rg->rg_usedmeta != rg_usedmeta) {
+ if (rgd->rt_usedmeta != rg_usedmeta) {
*this_rg_bad = 1;
*this_rg_cleaned = 0;
- log_err( _("Error: resource group %lld (0x%llx): used "
+ log_err(_("Error: resource group %"PRIu64" (0x%"PRIx64"): used
"
"metadata (%d) does not match bitmap (%d)\n"),
- (unsigned long long)rgd->ri.ri_addr,
- (unsigned long long)rgd->ri.ri_addr,
- gfs1rg->rg_usedmeta, rg_usedmeta);
+ rgd->rt_addr, rgd->rt_addr, rgd->rt_usedmeta, rg_usedmeta);
if (query( _("Fix the rgrp used meta blocks count? (y/n)"))) {
- gfs1rg->rg_usedmeta = rg_usedmeta;
- gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+ rgd->rt_usedmeta = rg_usedmeta;
+ lgfs2_gfs_rgrp_out(rgd, rgd->bits[0].bi_data);
rgd->bits[0].bi_modified = 1;
*this_rg_fixed = 1;
log_err( _("The rgrp was fixed.\n"));
@@ -665,8 +651,8 @@ static unsigned gfs2_rgrp_reada(struct gfs2_sbd *sdp, unsigned
cur_window,
if (i < cur_window)
continue;
rgd = (struct rgrp_tree *)n;
- start = rgd->ri.ri_addr * sdp->bsize;
- len = rgd->ri.ri_length * sdp->bsize;
+ start = rgd->rt_addr * sdp->bsize;
+ len = rgd->rt_length * sdp->bsize;
posix_fadvise(sdp->device_fd, start, len, POSIX_FADV_WILLNEED);
}
@@ -686,7 +672,6 @@ static unsigned gfs2_rgrp_reada(struct gfs2_sbd *sdp, unsigned
cur_window,
static int read_rgrps(struct gfs2_sbd *sdp, uint64_t expected)
{
struct rgrp_tree *rgd;
- struct gfs2_rindex *ri;
uint64_t count = 0;
uint64_t errblock = 0;
uint64_t rmax = 0;
@@ -708,9 +693,8 @@ static int read_rgrps(struct gfs2_sbd *sdp, uint64_t expected)
return errblock;
ra_window--;
count++;
- ri = &rgd->ri;
- if (ri->ri_data0 + ri->ri_data - 1 > rmax)
- rmax = ri->ri_data0 + ri->ri_data - 1;
+ if (rgd->rt_data0 + rgd->rt_data - 1 > rmax)
+ rmax = rgd->rt_data0 + rgd->rt_data - 1;
}
sdp->fssize = rmax;
diff --git a/gfs2/fsck/main.c b/gfs2/fsck/main.c
index e322b395..a7ea9bf2 100644
--- a/gfs2/fsck/main.c
+++ b/gfs2/fsck/main.c
@@ -167,7 +167,6 @@ static int check_statfs(struct gfs2_sbd *sdp)
{
struct osi_node *n, *next = NULL;
struct rgrp_tree *rgd;
- struct gfs2_rindex *ri;
struct gfs2_statfs_change sc;
uint64_t sc_total;
uint64_t sc_free;
@@ -197,10 +196,9 @@ static int check_statfs(struct gfs2_sbd *sdp)
for (n = osi_first(&sdp->rgtree); n; n = next) {
next = osi_next(n);
rgd = (struct rgrp_tree *)n;
- ri = &rgd->ri;
- sdp->blks_total += ri->ri_data;
- sdp->blks_alloced += (ri->ri_data - rgd->rg.rg_free);
- sdp->dinodes_alloced += rgd->rg.rg_dinodes;
+ sdp->blks_total += rgd->rt_data;
+ sdp->blks_alloced += (rgd->rt_data - rgd->rt_free);
+ sdp->dinodes_alloced += rgd->rt_dinodes;
}
/* See if they match */
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 991f1175..2543e2e5 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -35,7 +35,6 @@ int check_n_fix_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
int old_state;
int treat_as_inode = 0;
int rewrite_rgrp = 0;
- struct gfs_rgrp *gfs1rg;
const char *allocdesc[2][5] = { /* gfs2 descriptions */
{"free", "data", "unlinked", "inode",
"reserved"},
/* gfs1 descriptions: */
@@ -48,9 +47,6 @@ int check_n_fix_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
rgd = gfs2_blk2rgrpd(sdp, blk);
prevrgd = rgd;
}
-
- gfs1rg = (struct gfs_rgrp *)&rgd->rg;
-
old_state = lgfs2_get_bitmap(sdp, blk, rgd);
if (old_state < 0) {
log_err( _("Block %llu (0x%llx) is not represented in the "
@@ -87,10 +83,10 @@ int check_n_fix_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
data or data to dinode, no change in free space. */
gfs2_set_bitmap(rgd, blk, new_state);
if (new_state == GFS2_BLKST_FREE) {
- rgd->rg.rg_free++;
+ rgd->rt_free++;
rewrite_rgrp = 1;
} else if (old_state == GFS2_BLKST_FREE) {
- rgd->rg.rg_free--;
+ rgd->rt_free--;
rewrite_rgrp = 1;
}
/* If we're freeing a dinode, get rid of the data structs for it. */
@@ -117,10 +113,10 @@ int check_n_fix_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
treat_as_inode = 1;
}
if (old_state == GFS2_BLKST_DINODE) {
- if (treat_as_inode && rgd->rg.rg_dinodes > 0)
- rgd->rg.rg_dinodes--;
- else if (sdp->gfs1 && gfs1rg->rg_usedmeta > 0)
- gfs1rg->rg_usedmeta--;
+ if (treat_as_inode && rgd->rt_dinodes > 0)
+ rgd->rt_dinodes--;
+ else if (sdp->gfs1 && rgd->rt_usedmeta > 0)
+ rgd->rt_usedmeta--;
rewrite_rgrp = 1;
}
link1_set(&nlink1map, blk, 0);
@@ -148,16 +144,16 @@ int check_n_fix_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
}
}
if (treat_as_inode)
- rgd->rg.rg_dinodes++;
+ rgd->rt_dinodes++;
else if (sdp->gfs1)
- gfs1rg->rg_usedmeta++;
+ rgd->rt_usedmeta++;
rewrite_rgrp = 1;
}
if (rewrite_rgrp) {
if (sdp->gfs1)
- gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_gfs_rgrp_out(rgd, rgd->bits[0].bi_data);
else
- gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_rgrp_out(rgd, rgd->bits[0].bi_data);
rgd->bits[0].bi_modified = 1;
}
log_err( _("The bitmap was fixed.\n"));
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 3454fd56..f2ba4235 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -1944,7 +1944,7 @@ static int pass1_process_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree
*rgd)
if (ibuf == NULL)
return FSCK_ERROR;
- for (k = 0; k < rgd->ri.ri_length; k++) {
+ for (k = 0; k < rgd->rt_length; k++) {
n = lgfs2_bm_scan(rgd, k, ibuf, GFS2_BLKST_DINODE);
if (n) {
@@ -2116,11 +2116,10 @@ int pass1(struct gfs2_sbd *sdp)
next = osi_next(n);
log_debug("Checking metadata in resource group #%"PRIu64"\n",
rg_count);
rgd = (struct rgrp_tree *)n;
- for (i = 0; i < rgd->ri.ri_length; i++) {
+ for (i = 0; i < rgd->rt_length; i++) {
log_debug("rgrp block %"PRIu64" (0x%"PRIx64") is now marked
as 'rgrp data'\n",
- rgd->ri.ri_addr + i, rgd->ri.ri_addr + i);
- if (gfs2_blockmap_set(bl, rgd->ri.ri_addr + i,
- GFS2_BLKST_USED)) {
+ rgd->rt_addr + i, rgd->rt_addr + i);
+ if (gfs2_blockmap_set(bl, rgd->rt_addr + i, GFS2_BLKST_USED)) {
stack;
gfs2_special_free(&gfs1_rindex_blks);
ret = FSCK_ERROR;
diff --git a/gfs2/fsck/pass5.c b/gfs2/fsck/pass5.c
index 33265bfa..cb60415b 100644
--- a/gfs2/fsck/pass5.c
+++ b/gfs2/fsck/pass5.c
@@ -133,57 +133,48 @@ static void update_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree
*rgp,
struct gfs2_bitmap *bits;
uint64_t rg_block = 0;
int update = 0;
- struct gfs_rgrp *gfs1rg = (struct gfs_rgrp *)&rgp->rg;
- for(i = 0; i < rgp->ri.ri_length; i++) {
+ for(i = 0; i < rgp->rt_length; i++) {
bits = &rgp->bits[i];
/* update the bitmaps */
if (check_block_status(sdp, bl, bits->bi_data + bits->bi_offset,
- bits->bi_len, &rg_block, rgp->ri.ri_data0, count))
+ bits->bi_len, &rg_block, rgp->rt_data0, count))
return;
if (skip_this_pass || fsck_abort) /* if asked to skip the rest */
return;
}
/* actually adjust counters and write out to disk */
- if (rgp->rg.rg_free != count[GFS2_BLKST_FREE]) {
- log_err( _("RG #%llu (0x%llx) free count inconsistent: "
+ if (rgp->rt_free != count[GFS2_BLKST_FREE]) {
+ log_err(_("RG #%"PRIu64" (0x%"PRIx64") free count
inconsistent: "
"is %u should be %u\n"),
- (unsigned long long)rgp->ri.ri_addr,
- (unsigned long long)rgp->ri.ri_addr,
- rgp->rg.rg_free, count[GFS2_BLKST_FREE]);
- rgp->rg.rg_free = count[GFS2_BLKST_FREE];
+ rgp->rt_addr, rgp->rt_addr, rgp->rt_free, count[GFS2_BLKST_FREE]);
+ rgp->rt_free = count[GFS2_BLKST_FREE];
update = 1;
}
- if (rgp->rg.rg_dinodes != count[GFS2_BLKST_DINODE]) {
- log_err( _("RG #%llu (0x%llx) Inode count inconsistent: is "
- "%u should be %u\n"),
- (unsigned long long)rgp->ri.ri_addr,
- (unsigned long long)rgp->ri.ri_addr,
- rgp->rg.rg_dinodes, count[GFS2_BLKST_DINODE]);
- rgp->rg.rg_dinodes = count[GFS2_BLKST_DINODE];
+ if (rgp->rt_dinodes != count[GFS2_BLKST_DINODE]) {
+ log_err(_("RG #%"PRIu64" (0x%"PRIx64") Inode count
inconsistent: is "
+ "%u should be %u\n"),
+ rgp->rt_addr, rgp->rt_addr, rgp->rt_dinodes,
count[GFS2_BLKST_DINODE]);
+ rgp->rt_dinodes = count[GFS2_BLKST_DINODE];
update = 1;
}
- if (sdp->gfs1 && gfs1rg->rg_usedmeta != count[GFS1_BLKST_USEDMETA]) {
- log_err( _("RG #%llu (0x%llx) Used metadata count "
- "inconsistent: is %u should be %u\n"),
- (unsigned long long)rgp->ri.ri_addr,
- (unsigned long long)rgp->ri.ri_addr,
- gfs1rg->rg_usedmeta, count[GFS1_BLKST_USEDMETA]);
- gfs1rg->rg_usedmeta = count[GFS1_BLKST_USEDMETA];
+ if (sdp->gfs1 && rgp->rt_usedmeta != count[GFS1_BLKST_USEDMETA]) {
+ log_err(_("RG #%"PRIu64" (0x%"PRIx64") Used metadata count
"
+ "inconsistent: is %u should be %u\n"),
+ rgp->rt_addr, rgp->rt_addr, rgp->rt_usedmeta,
count[GFS1_BLKST_USEDMETA]);
+ rgp->rt_usedmeta = count[GFS1_BLKST_USEDMETA];
update = 1;
}
- if (sdp->gfs1 && gfs1rg->rg_freemeta != count[GFS2_BLKST_UNLINKED]) {
- log_err( _("RG #%llu (0x%llx) Free metadata count "
- "inconsistent: is %u should be %u\n"),
- (unsigned long long)rgp->ri.ri_addr,
- (unsigned long long)rgp->ri.ri_addr,
- gfs1rg->rg_freemeta, count[GFS2_BLKST_UNLINKED]);
- gfs1rg->rg_freemeta = count[GFS2_BLKST_UNLINKED];
+ if (sdp->gfs1 && rgp->rt_freemeta != count[GFS2_BLKST_UNLINKED]) {
+ log_err(_("RG #%"PRIu64" (0x%"PRIx64") Free metadata count
"
+ "inconsistent: is %u should be %u\n"),
+ rgp->rt_addr, rgp->rt_addr, rgp->rt_freemeta,
count[GFS2_BLKST_UNLINKED]);
+ rgp->rt_freemeta = count[GFS2_BLKST_UNLINKED];
update = 1;
}
- if (!sdp->gfs1 && (rgp->ri.ri_data != count[GFS2_BLKST_FREE] +
+ if (!sdp->gfs1 && (rgp->rt_data != count[GFS2_BLKST_FREE] +
count[GFS2_BLKST_USED] +
count[GFS2_BLKST_UNLINKED] +
count[GFS2_BLKST_DINODE])) {
@@ -191,7 +182,7 @@ static void update_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree *rgp,
* means that the total number of blocks we've counted
* exceeds the blocks in the rg */
log_err( _("Internal fsck error: %u != %u + %u + %u + %u\n"),
- rgp->ri.ri_data, count[GFS2_BLKST_FREE],
+ rgp->rt_data, count[GFS2_BLKST_FREE],
count[GFS2_BLKST_USED], count[GFS2_BLKST_UNLINKED],
count[GFS2_BLKST_DINODE]);
exit(FSCK_ERROR);
@@ -201,9 +192,9 @@ static void update_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree *rgp,
log_warn( _("Resource group counts updated\n"));
/* write out the rgrp */
if (sdp->gfs1)
- gfs_rgrp_out(gfs1rg, rgp->bits[0].bi_data);
+ lgfs2_gfs_rgrp_out(rgp, rgp->bits[0].bi_data);
else
- gfs2_rgrp_out(&rgp->rg, rgp->bits[0].bi_data);
+ lgfs2_rgrp_out(rgp, rgp->bits[0].bi_data);
rgp->bits[0].bi_modified = 1;
} else
log_err( _("Resource group counts left inconsistent\n"));
diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c
index 316be67c..029f0711 100644
--- a/gfs2/fsck/rgrepair.c
+++ b/gfs2/fsck/rgrepair.c
@@ -23,14 +23,12 @@ struct special_blocks false_rgrps;
#define AWAY_FROM_BITMAPS 0x1000
#define MAX_RGSEGMENTS 20
-#define ri_equal(ondisk, expected, field) (ondisk.field == expected.field)
-
-#define ri_compare(rg, ondisk, expected, field, fmt, type) \
- if (ondisk.field != expected.field) { \
+#define ri_compare(rg, ondisk, expected, field, fmt) \
+ if (ondisk->field != expected->field) { \
log_warn( _("rindex #%d " #field " discrepancy: index 0x%" \
fmt " != expected: 0x%" fmt "\n"), \
- rg + 1, (type)ondisk.field, (type)expected.field); \
- ondisk.field = expected.field; \
+ rg + 1, ondisk->field, expected->field); \
+ ondisk->field = expected->field; \
rindex_modified = 1; \
}
@@ -104,7 +102,6 @@ static int find_shortest_rgdist(struct gfs2_sbd *sdp, uint64_t
*dist_array,
uint64_t blk, block_last_rg, shortest_dist_btwn_rgs;
struct gfs2_buffer_head *bh;
int rgs_sampled = 0;
- struct gfs2_rindex buf, tmpndx;
uint64_t initial_first_rg_dist;
int gsegment = 0;
int is_rgrp;
@@ -238,14 +235,14 @@ static int find_shortest_rgdist(struct gfs2_sbd *sdp, uint64_t
*dist_array,
/* -------------------------------------------------------------- */
if (*dist_array >= shortest_dist_btwn_rgs +
(shortest_dist_btwn_rgs / 4)) {
+ struct gfs2_rindex ri;
+
/* read in the second RG index entry for this subd. */
- gfs2_readi(sdp->md.riinode, (char *)&buf,
- sizeof(struct gfs2_rindex),
- sizeof(struct gfs2_rindex));
- gfs2_rindex_in(&tmpndx, (char *)&buf);
- if (tmpndx.ri_addr > LGFS2_SB_ADDR(sdp) + 1) { /* sanity check */
+ gfs2_readi(sdp->md.riinode, &ri, sizeof(ri), sizeof(ri));
+
+ if (be64_to_cpu(ri.ri_addr) > LGFS2_SB_ADDR(sdp) + 1) { /* sanity check */
log_warn( _("rgrp 2 is damaged: getting dist from index: "));
- *dist_array = tmpndx.ri_addr - (LGFS2_SB_ADDR(sdp) + 1);
+ *dist_array = be64_to_cpu(ri.ri_addr) - (LGFS2_SB_ADDR(sdp) + 1);
log_warn("0x%llx\n", (unsigned long long)*dist_array);
} else {
log_warn( _("rgrp index 2 is damaged: extrapolating dist: "));
@@ -330,13 +327,13 @@ static uint64_t find_next_rgrp_dist(struct gfs2_sbd *sdp, uint64_t
blk,
for (n = osi_first(&sdp->rgtree); n; n = next) {
next = osi_next(n);
rgd = (struct rgrp_tree *)n;
- if (rgd->ri.ri_addr == blk)
+ if (rgd->rt_addr == blk)
break;
}
- if (rgd && n && osi_next(n) && rgd->ri.ri_addr == blk) {
+ if (rgd && n && osi_next(n) && rgd->rt_addr == blk) {
n = osi_next(n);
next_rgd = (struct rgrp_tree *)n;
- rgrp_dist = next_rgd->ri.ri_addr - rgd->ri.ri_addr;
+ rgrp_dist = next_rgd->rt_addr - rgd->rt_addr;
return rgrp_dist;
}
mega_in_blocks = (1024 * 1024) / sdp->bsize;
@@ -352,13 +349,13 @@ static uint64_t find_next_rgrp_dist(struct gfs2_sbd *sdp, uint64_t
blk,
skip a few blocks (hopefully no more than 4). */
used_blocks = 0;
length = 0;
- block = prevrgd->ri.ri_addr;
+ block = prevrgd->rt_addr;
first = 1;
found = 0;
while (1) {
if (block >= sdp->device.length)
break;
- if (block >= prevrgd->ri.ri_addr + twogigs)
+ if (block >= prevrgd->rt_addr + twogigs)
break;
bh = bread(sdp, block);
gfs2_meta_header_in(&mh, bh->b_data);
@@ -388,7 +385,7 @@ static uint64_t find_next_rgrp_dist(struct gfs2_sbd *sdp, uint64_t
blk,
bitmap blocks. Count them all as bitmaps and you'll be
hopelessly lost. */
rgrp_dist = used_blocks + free_blocks + length;
- next_block = prevrgd->ri.ri_addr + rgrp_dist;
+ next_block = prevrgd->rt_addr + rgrp_dist;
/* Now we account for block rounding done by mkfs.gfs2 */
for (b = 0; b <= length + GFS2_NBBY; b++) {
if (next_block + b >= sdp->device.length)
@@ -414,7 +411,7 @@ static uint64_t find_next_rgrp_dist(struct gfs2_sbd *sdp, uint64_t
blk,
}
if (found) {
log_info(_("rgrp found at 0x%"PRIx64", length=%d,
used=%"PRIu64", free=%d\n"),
- prevrgd->ri.ri_addr, length, used_blocks, free_blocks);
+ prevrgd->rt_addr, length, used_blocks, free_blocks);
break;
}
}
@@ -452,7 +449,7 @@ static uint64_t hunt_and_peck(struct gfs2_sbd *sdp, uint64_t blk,
rgrp_dist = AWAY_FROM_BITMAPS; /* Get away from any bitmaps
associated with the previous rgrp */
- block = prevrgd->ri.ri_addr + rgrp_dist;
+ block = prevrgd->rt_addr + rgrp_dist;
/* Now we account for block rounding done by mkfs.gfs2. A rgrp can
be at most 2GB in size, so that's where we call it. We do somewhat
obscure math here to avoid integer overflows. */
@@ -565,7 +562,7 @@ static int rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs, int
gfs_grow)
log_crit( _("Can't allocate memory for rgrp repair.\n"));
goto out;
}
- calc_rgd->ri.ri_length = 1;
+ calc_rgd->rt_length = 1;
if (!rg_was_fnd) { /* if not an RG */
/* ------------------------------------------------- */
/* This SHOULD be an RG but isn't. */
@@ -592,26 +589,25 @@ static int rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs, int
gfs_grow)
bitmap_was_fnd = !gfs2_check_meta(bh->b_data, GFS2_METATYPE_RB);
brelse(bh);
if (bitmap_was_fnd) /* if a bitmap */
- calc_rgd->ri.ri_length++;
+ calc_rgd->rt_length++;
else
break; /* end of bitmap, so call it quits. */
} /* for subsequent bitmaps */
- calc_rgd->ri.ri_data0 = calc_rgd->ri.ri_addr +
- calc_rgd->ri.ri_length;
+ calc_rgd->rt_data0 = calc_rgd->rt_addr +
+ calc_rgd->rt_length;
if (prev_rgd) {
uint32_t rgblocks;
- prev_rgd->ri.ri_length = rgblocks2bitblocks(sdp->bsize, block_bump,
&rgblocks);
- prev_rgd->ri.ri_data = rgblocks;
- prev_rgd->ri.ri_data0 = prev_rgd->ri.ri_addr +
- prev_rgd->ri.ri_length;
- prev_rgd->ri.ri_data -= prev_rgd->ri.ri_data %
+ prev_rgd->rt_length = rgblocks2bitblocks(sdp->bsize, block_bump,
&rgblocks);
+ prev_rgd->rt_data = rgblocks;
+ prev_rgd->rt_data0 = prev_rgd->rt_addr +
+ prev_rgd->rt_length;
+ prev_rgd->rt_data -= prev_rgd->rt_data %
GFS2_NBBY;
- prev_rgd->ri.ri_bitbytes = prev_rgd->ri.ri_data /
+ prev_rgd->rt_bitbytes = prev_rgd->rt_data /
GFS2_NBBY;
- log_debug( _("Prev ri_data set to: %lx.\n"),
- (unsigned long)prev_rgd->ri.ri_data);
+ log_debug(_("Prev ri_data set to: 0x%"PRIx32"\n"),
prev_rgd->rt_data);
}
number_of_rgs++;
segment_rgs++;
@@ -662,17 +658,15 @@ static int rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs, int
gfs_grow)
/* If we got to the end of the fs, we still need to fix the */
/* allocation information for the very last RG. */
/* ----------------------------------------------------------------- */
- if (prev_rgd && !prev_rgd->ri.ri_data) {
+ if (prev_rgd && !prev_rgd->rt_data) {
uint32_t rgblocks;
- prev_rgd->ri.ri_length = rgblocks2bitblocks(sdp->bsize, block_bump,
&rgblocks);
- prev_rgd->ri.ri_data0 = prev_rgd->ri.ri_addr +
- prev_rgd->ri.ri_length;
- prev_rgd->ri.ri_data = rgblocks;
- prev_rgd->ri.ri_data -= prev_rgd->ri.ri_data % GFS2_NBBY;
- prev_rgd->ri.ri_bitbytes = prev_rgd->ri.ri_data / GFS2_NBBY;
- log_debug( _("Prev ri_data set to: %lx.\n"),
- (unsigned long)prev_rgd->ri.ri_data);
+ prev_rgd->rt_length = rgblocks2bitblocks(sdp->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;
+ prev_rgd->rt_bitbytes = prev_rgd->rt_data / GFS2_NBBY;
+ log_debug(_("Prev ri_data set to: 0x%"PRIx32"\n"),
prev_rgd->rt_data);
prev_rgd = NULL; /* make sure we don't use it later */
}
/* ---------------------------------------------- */
@@ -683,9 +677,9 @@ static int rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs, int
gfs_grow)
next = osi_next(n);
calc_rgd = (struct rgrp_tree *)n;
log_debug("%d:
0x%"PRIx64"/%"PRIx32"/0x%"PRIx64"/0x%"PRIx32"/0x%"PRIx32"\n",
- rgi + 1, calc_rgd->ri.ri_addr, calc_rgd->ri.ri_length,
- calc_rgd->ri.ri_data0, calc_rgd->ri.ri_data,
- calc_rgd->ri.ri_bitbytes);
+ rgi + 1, calc_rgd->rt_addr, calc_rgd->rt_length,
+ calc_rgd->rt_data0, calc_rgd->rt_data,
+ calc_rgd->rt_bitbytes);
}
*num_rgs = number_of_rgs;
error = 0;
@@ -783,10 +777,10 @@ static void compute_rgrp_layout(struct gfs2_sbd *sdp, struct
osi_root *rgtree, i
rl->length, rl->length);
rlast = rl;
}
- rlast->start = rlast->ri.ri_addr;
+ rlast->start = rlast->rt_addr;
rglength = rgrp_size(rlast);
rlast->length = rglength;
- old_length = rlast->ri.ri_addr + rglength;
+ old_length = rlast->rt_addr + rglength;
new_chunk = dev->length - old_length;
sdp->new_rgrps = new_chunk / rglength;
nrgrp = rgrp + sdp->new_rgrps;
@@ -821,32 +815,25 @@ static int calc_rgrps(struct gfs2_sbd *sdp)
struct osi_node *n, *next = NULL;
struct rgrp_tree *rl;
uint32_t rgblocks, bitblocks;
- struct gfs2_rindex *ri;
for (n = osi_first(&sdp->rgcalc); n; n = next) {
next = osi_next(n);
rl = (struct rgrp_tree *)n;
- ri = &rl->ri;
bitblocks = rgblocks2bitblocks(sdp->bsize, rl->length, &rgblocks);
- ri->ri_addr = rl->start;
- ri->ri_length = bitblocks;
- ri->ri_data0 = rl->start + bitblocks;
- ri->ri_data = rgblocks;
- ri->ri_bitbytes = rgblocks / GFS2_NBBY;
-
- memset(&rl->rg, 0, sizeof(rl->rg));
- rl->rg.rg_header.mh_magic = GFS2_MAGIC;
- rl->rg.rg_header.mh_type = GFS2_METATYPE_RG;
- rl->rg.rg_header.mh_format = GFS2_FORMAT_RG;
- rl->rg.rg_free = rgblocks;
+ rl->rt_addr = rl->start;
+ rl->rt_length = bitblocks;
+ rl->rt_data0 = rl->start + bitblocks;
+ rl->rt_data = rgblocks;
+ rl->rt_bitbytes = rgblocks / GFS2_NBBY;
+ rl->rt_free = rgblocks;
if (gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, rl))
return -1;
sdp->blks_total += rgblocks;
- sdp->fssize = ri->ri_data0 + ri->ri_data;
+ sdp->fssize = rl->rt_data0 + rl->rt_data;
}
return 0;
}
@@ -910,15 +897,13 @@ static int gfs2_rindex_calculate(struct gfs2_sbd *sdp, int
*num_rgs)
static int rewrite_rg_block(struct gfs2_sbd *sdp, struct rgrp_tree *rg,
uint64_t errblock)
{
- int x = errblock - rg->ri.ri_addr;
+ int x = errblock - rg->rt_addr;
const char *typedesc = x ? "GFS2_METATYPE_RB" : "GFS2_METATYPE_RG";
ssize_t ret;
char *buf;
- log_err( _("Block #%lld (0x%llx) (%d of %d) is not %s.\n"),
- (unsigned long long)rg->ri.ri_addr + x,
- (unsigned long long)rg->ri.ri_addr + x,
- (int)x+1, (int)rg->ri.ri_length, typedesc);
+ log_err(_("Block #%"PRIu64" (0x%"PRIx64") (%d of
%"PRIu32") is not %s.\n"),
+ rg->rt_addr + x, rg->rt_addr + x, x+1, rg->rt_length, typedesc);
if (!query( _("Fix the resource group? (y/n)")))
return 1;
@@ -944,18 +929,11 @@ static int rewrite_rg_block(struct gfs2_sbd *sdp, struct rgrp_tree
*rg,
};
gfs2_meta_header_out(&mh, buf);
} else {
+ rg->rt_free = rg->rt_data;
if (sdp->gfs1)
- memset(&rg->rg, 0, sizeof(struct gfs_rgrp));
- else
- memset(&rg->rg, 0, sizeof(struct gfs2_rgrp));
- rg->rg.rg_header.mh_magic = GFS2_MAGIC;
- rg->rg.rg_header.mh_type = GFS2_METATYPE_RG;
- rg->rg.rg_header.mh_format = GFS2_FORMAT_RG;
- rg->rg.rg_free = rg->ri.ri_data;
- if (sdp->gfs1)
- gfs_rgrp_out((struct gfs_rgrp *)&rg->rg, buf);
+ lgfs2_gfs_rgrp_out(rg, buf);
else
- gfs2_rgrp_out(&rg->rg, buf);
+ lgfs2_rgrp_out(rg, buf);
}
ret = pwrite(sdp->device_fd, buf, sdp->bsize, errblock * sdp->bsize);
if (ret != sdp->bsize) {
@@ -982,15 +960,22 @@ 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(&sdp->rgcalc, rgd->ri.ri_addr);
+ exp = rgrp_insert(&sdp->rgcalc, rgd->rt_addr);
if (exp == NULL) {
fprintf(stderr, "Out of memory in %s\n", __FUNCTION__);
exit(-1);
}
exp->start = rgd->start;
exp->length = rgd->length;
- memcpy(&exp->ri, &rgd->ri, sizeof(exp->ri));
- memcpy(&exp->rg, &rgd->rg, sizeof(exp->rg));
+ exp->rt_data0 = rgd->rt_data0;
+ exp->rt_data = rgd->rt_data;
+ exp->rt_length = rgd->rt_length;
+ exp->rt_bitbytes = rgd->rt_bitbytes;
+ exp->rt_flags = rgd->rt_flags;
+ exp->rt_free = rgd->rt_free;
+ exp->rt_igeneration = rgd->rt_igeneration;
+ exp->rt_dinodes = rgd->rt_dinodes;
+ exp->rt_skip = rgd->rt_skip;
exp->bits = NULL;
gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, exp);
}
@@ -1127,26 +1112,26 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok)
expected = (struct rgrp_tree *)e;
actual = (struct rgrp_tree *)n;
- if (actual->ri.ri_addr < expected->ri.ri_addr) {
+ if (actual->rt_addr < expected->rt_addr) {
n = next;
discrepancies++;
log_info(_("%d addr: 0x%"PRIx64" < 0x%"PRIx64" *
mismatch\n"),
- rg + 1, actual->ri.ri_addr, expected->ri.ri_addr);
+ rg + 1, actual->rt_addr, expected->rt_addr);
continue;
- } else if (expected->ri.ri_addr < actual->ri.ri_addr) {
+ } else if (expected->rt_addr < actual->rt_addr) {
e = enext;
discrepancies++;
log_info(_("%d addr: 0x%"PRIx64" > 0x%"PRIx64" *
mismatch\n"),
- rg + 1, actual->ri.ri_addr, expected->ri.ri_addr);
+ rg + 1, actual->rt_addr, expected->rt_addr);
continue;
}
- if (!ri_equal(actual->ri, expected->ri, ri_length) ||
- !ri_equal(actual->ri, expected->ri, ri_data0) ||
- !ri_equal(actual->ri, expected->ri, ri_data) ||
- !ri_equal(actual->ri, expected->ri, ri_bitbytes)) {
+ if (actual->rt_length != expected->rt_length ||
+ actual->rt_data0 != expected->rt_data0 ||
+ actual->rt_data != expected->rt_data ||
+ actual->rt_bitbytes != expected->rt_bitbytes) {
discrepancies++;
log_info(_("%d addr: 0x%"PRIx64" 0x%"PRIx64" * has
mismatch\n"),
- rg + 1, actual->ri.ri_addr, expected->ri.ri_addr);
+ rg + 1, actual->rt_addr, expected->rt_addr);
}
n = next;
e = enext;
@@ -1187,10 +1172,10 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok)
If we ran out of actual rindex entries due to rindex
damage, fill in a new one with the expected values. */
if (!n || /* end of actual rindex */
- expected->ri.ri_addr < actual->ri.ri_addr) {
+ expected->rt_addr < actual->rt_addr) {
log_err(_("Entry missing from rindex: 0x%"PRIx64"\n"),
- expected->ri.ri_addr);
- actual = rgrp_insert(&sdp->rgtree, expected->ri.ri_addr);
+ expected->rt_addr);
+ actual = rgrp_insert(&sdp->rgtree, expected->rt_addr);
if (!actual) {
log_err(_("Out of memory!\n"));
break;
@@ -1199,30 +1184,24 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok)
next = n; /* Ensure that the old actual gets checked
against a new expected, since we added */
} else {
- ri_compare(rg, actual->ri, expected->ri, ri_addr,
- "llx", unsigned long long);
- ri_compare(rg, actual->ri, expected->ri, ri_length,
- "lx", unsigned long);
- ri_compare(rg, actual->ri, expected->ri, ri_data0,
- "llx", unsigned long long);
- ri_compare(rg, actual->ri, expected->ri, ri_data,
- "lx", unsigned long);
- ri_compare(rg, actual->ri, expected->ri, ri_bitbytes,
- "lx", unsigned long);
+ ri_compare(rg, actual, expected, rt_addr, PRIx64);
+ ri_compare(rg, actual, expected, rt_length, PRIx32);
+ ri_compare(rg, actual, expected, rt_data0, PRIx64);
+ ri_compare(rg, actual, expected, rt_data, PRIx32);
+ ri_compare(rg, actual, expected, rt_bitbytes, PRIx32);
}
/* If we modified the index, write it back to disk. */
if (rindex_modified) {
if (query( _("Fix the index? (y/n)"))) {
- gfs2_rindex_out(&expected->ri, (char *)&buf);
+ lgfs2_rindex_out(expected, (char *)&buf);
gfs2_writei(sdp->md.riinode, (char *)&buf,
rg * sizeof(struct gfs2_rindex),
sizeof(struct gfs2_rindex));
- actual->ri.ri_addr = expected->ri.ri_addr;
- actual->ri.ri_length = expected->ri.ri_length;
- actual->ri.ri_data0 = expected->ri.ri_data0;
- actual->ri.ri_data = expected->ri.ri_data;
- actual->ri.ri_bitbytes =
- expected->ri.ri_bitbytes;
+ actual->rt_addr = expected->rt_addr;
+ actual->rt_length = expected->rt_length;
+ actual->rt_data0 = expected->rt_data0;
+ 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 */
/* have malloced the wrong length for bitmap */
@@ -1269,7 +1248,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok)
break;
}
i++;
- } while (i < rgd->ri.ri_length);
+ } while (i < rgd->rt_length);
}
gfs2_rgrp_free(sdp, &sdp->rgcalc);
gfs2_rgrp_free(sdp, &sdp->rgtree);
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index 84022814..dfc4512c 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -544,7 +544,6 @@ uint64_t find_free_blk(struct gfs2_sbd *sdp)
{
struct osi_node *n, *next = NULL;
struct rgrp_tree *rl = NULL;
- struct gfs2_rindex *ri;
struct gfs2_rgrp *rg;
unsigned int block, bn = 0, x = 0, y = 0;
unsigned int state;
@@ -553,17 +552,14 @@ uint64_t find_free_blk(struct gfs2_sbd *sdp)
for (n = osi_first(&sdp->rgtree); n; n = next) {
next = osi_next(n);
rl = (struct rgrp_tree *)n;
- if (rl->rg.rg_free)
+ if (rl->rt_free)
break;
}
if (n == NULL)
return 0;
- ri = &rl->ri;
- rg = &rl->rg;
-
- for (block = 0; block < ri->ri_length; block++) {
+ for (block = 0; block < rl->rt_length; block++) {
char *buf = rl->bits[block].bi_data;
x = (block) ? sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_rgrp);
@@ -571,7 +567,7 @@ uint64_t find_free_blk(struct gfs2_sbd *sdp)
for (y = 0; y < GFS2_NBBY; y++) {
state = (buf[x] >> (GFS2_BIT_SIZE * y)) & 0x03;
if (state == GFS2_BLKST_FREE)
- return ri->ri_data0 + bn;
+ return rl->rt_data0 + bn;
bn++;
}
}
diff --git a/gfs2/libgfs2/check_rgrp.c b/gfs2/libgfs2/check_rgrp.c
index 98650e24..dd31a341 100644
--- a/gfs2/libgfs2/check_rgrp.c
+++ b/gfs2/libgfs2/check_rgrp.c
@@ -71,7 +71,7 @@ START_TEST(test_rbm_find_good)
rbm.rgd = lgfs2_rgrp_first(rgs);
/* Check that extent sizes up to the whole rg can be found */
- for (minext = 1; minext <= rbm.rgd->ri.ri_data; minext++) {
+ for (minext = 1; minext <= rbm.rgd->rt_data; minext++) {
int err;
uint64_t addr;
@@ -81,7 +81,7 @@ START_TEST(test_rbm_find_good)
ck_assert_int_eq(err, 0);
addr = lgfs2_rbm_to_block(&rbm);
- ck_assert(addr == rbm.rgd->ri.ri_data0);
+ ck_assert(addr == rbm.rgd->rt_data0);
}
}
END_TEST
@@ -94,7 +94,7 @@ START_TEST(test_rbm_find_bad)
lgfs2_rgrps_t rgs = tc_rgrps;
rbm.rgd = lgfs2_rgrp_first(rgs);
- minext = rbm.rgd->ri.ri_data + 1;
+ minext = rbm.rgd->rt_data + 1;
err = lgfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &minext);
ck_assert_int_eq(err, 1);
@@ -114,42 +114,45 @@ START_TEST(test_rbm_find_lastblock)
rbm.rgd = rg = lgfs2_rgrp_first(rgs);
/* Flag all blocks as allocated... */
- for (i = 0; i < rg->ri.ri_length; i++)
+ for (i = 0; i < rg->rt_length; i++)
memset(rg->bits[i].bi_data, 0xff, rgs->sdp->bsize);
/* ...except the final one */
- err = gfs2_set_bitmap(rg, rg->ri.ri_data0 + rg->ri.ri_data - 1, GFS2_BLKST_FREE);
+ err = gfs2_set_bitmap(rg, rg->rt_data0 + rg->rt_data - 1, GFS2_BLKST_FREE);
ck_assert_int_eq(err, 0);
err = lgfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &minext);
ck_assert_int_eq(err, 0);
addr = lgfs2_rbm_to_block(&rbm);
- ck_assert(addr == (rg->ri.ri_data0 + rg->ri.ri_data - 1));
+ ck_assert(addr == (rg->rt_data0 + rg->rt_data - 1));
}
END_TEST
START_TEST(test_rgrps_write_final)
{
lgfs2_rgrp_t rg = lgfs2_rgrp_last(tc_rgrps);
- uint64_t addr = lgfs2_rgrp_index(rg)->ri_addr;
struct gfs2_sbd *sdp = tc_rgrps->sdp;
+ struct gfs2_rindex ri;
struct gfs2_rgrp rgrp;
+ uint64_t addr;
char *buf;
+ lgfs2_rindex_out(rg, &ri);
+ addr = be64_to_cpu(ri.ri_addr);
+
buf = malloc(4096);
ck_assert(buf != NULL);
memset(buf, 0xff, sizeof(rgrp));
ck_assert(pwrite(sdp->device_fd, buf, 4096, addr * 4096) == 4096);
ck_assert(lgfs2_rgrps_write_final(sdp->device_fd, tc_rgrps) == 0);
- ck_assert(pread(sdp->device_fd, buf, 4096, addr * 4096) == 4096);
- gfs2_rgrp_in(&rgrp, buf);
- free(buf);
+ ck_assert(pread(sdp->device_fd, &rgrp, sizeof(rgrp), addr * 4096) ==
sizeof(rgrp));
- ck_assert(rgrp.rg_header.mh_magic == GFS2_MAGIC);
- ck_assert(rgrp.rg_header.mh_type == GFS2_METATYPE_RG);
+ ck_assert(be32_to_cpu(rgrp.rg_header.mh_magic) == GFS2_MAGIC);
+ ck_assert(be32_to_cpu(rgrp.rg_header.mh_type) == GFS2_METATYPE_RG);
ck_assert(rgrp.rg_skip == 0);
+ free(buf);
ck_assert(lgfs2_rgrps_write_final(-1, tc_rgrps) == -1);
}
diff --git a/gfs2/libgfs2/fs_bits.c b/gfs2/libgfs2/fs_bits.c
index f600f6eb..72d2b006 100644
--- a/gfs2/libgfs2/fs_bits.c
+++ b/gfs2/libgfs2/fs_bits.c
@@ -136,11 +136,11 @@ int gfs2_set_bitmap(lgfs2_rgrp_t rgd, uint64_t blkno, int state)
if ((state < GFS2_BLKST_FREE) || (state > GFS2_BLKST_DINODE))
return -1;
- if(!rgd || blkno < rgd->ri.ri_data0)
+ if(!rgd || blkno < rgd->rt_data0)
return -1;
- rgrp_block = (uint32_t)(blkno - rgd->ri.ri_data0);
- for(buf= 0; buf < rgd->ri.ri_length; buf++){
+ rgrp_block = (uint32_t)(blkno - rgd->rt_data0);
+ for(buf= 0; buf < rgd->rt_length; buf++){
bits = &(rgd->bits[buf]);
if(rgrp_block < ((bits->bi_start + bits->bi_len)*GFS2_NBBY))
break;
@@ -189,12 +189,12 @@ int lgfs2_get_bitmap(struct gfs2_sbd *sdp, uint64_t blkno, struct
rgrp_tree *rgd
return -1;
}
- offset = blkno - rgd->ri.ri_data0;
+ offset = blkno - rgd->rt_data0;
if (offset > UINT_MAX) {
errno = EINVAL;
return -1;
}
- if (offset >= rgd->ri.ri_data0 + rgd->ri.ri_data) {
+ if (offset >= rgd->rt_data0 + rgd->rt_data) {
errno = E2BIG;
return -1;
}
diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index ccb75df3..c0569257 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
@@ -117,19 +117,19 @@ static uint64_t find_free_block(struct rgrp_tree *rgd)
unsigned bm;
uint64_t blkno = 0;
- if (rgd == NULL || rgd->rg.rg_free == 0) {
+ if (rgd == NULL || rgd->rt_free == 0) {
errno = ENOSPC;
return 0;
}
- for (bm = 0; bm < rgd->ri.ri_length; bm++) {
+ for (bm = 0; bm < rgd->rt_length; bm++) {
unsigned long blk = 0;
struct gfs2_bitmap *bits = &rgd->bits[bm];
blk = gfs2_bitfit((uint8_t *)bits->bi_data + bits->bi_offset,
bits->bi_len, blk, GFS2_BLKST_FREE);
if (blk != BFITNOENT) {
- blkno = blk + (bits->bi_start * GFS2_NBBY) + rgd->ri.ri_data0;
+ blkno = blk + (bits->bi_start * GFS2_NBBY) + rgd->rt_data0;
break;
}
}
@@ -145,19 +145,17 @@ static int blk_alloc_in_rg(struct gfs2_sbd *sdp, unsigned state,
struct rgrp_tre
return -1;
if (state == GFS2_BLKST_DINODE) {
- struct gfs_rgrp *gfs1rg = (struct gfs_rgrp *)&rgd->rg;
-
if (dinode)
- rgd->rg.rg_dinodes++;
+ rgd->rt_dinodes++;
else if (sdp->gfs1)
- gfs1rg->rg_usedmeta++;
+ rgd->rt_usedmeta++;
}
- rgd->rg.rg_free--;
+ rgd->rt_free--;
if (sdp->gfs1)
- gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_gfs_rgrp_out(rgd, rgd->bits[0].bi_data);
else
- gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_rgrp_out(rgd, rgd->bits[0].bi_data);
rgd->bits[0].bi_modified = 1;
sdp->blks_alloced++;
return 0;
@@ -178,7 +176,7 @@ static int block_alloc(struct gfs2_sbd *sdp, const uint64_t blksreq,
int state,
for (n = osi_first(&sdp->rgtree); n; n = osi_next(n)) {
rgt = (struct rgrp_tree *)n;
- if (rgt->rg.rg_free >= blksreq)
+ if (rgt->rt_free >= blksreq)
break;
}
if (rgt == NULL)
@@ -350,8 +348,8 @@ int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct
gfs2_inode *ip, u
ip->i_height = calc_tree_height(ip, di_size);
ip->i_flags = flags;
- rg->rg.rg_free -= blocks;
- rg->rg.rg_dinodes += 1;
+ rg->rt_free -= blocks;
+ rg->rt_dinodes += 1;
sdp->dinodes_alloced++;
sdp->blks_alloced += blocks;
@@ -1898,11 +1896,11 @@ void gfs2_free_block(struct gfs2_sbd *sdp, uint64_t block)
rgd = gfs2_blk2rgrpd(sdp, block); /* find the rg for indir block */
if (rgd) {
gfs2_set_bitmap(rgd, block, GFS2_BLKST_FREE);
- rgd->rg.rg_free++; /* adjust the free count */
+ rgd->rt_free++; /* adjust the free count */
if (sdp->gfs1)
- gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_gfs_rgrp_out(rgd, rgd->bits[0].bi_data);
else
- gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_rgrp_out(rgd, rgd->bits[0].bi_data);
rgd->bits[0].bi_modified = 1;
sdp->blks_alloced--;
}
@@ -1967,12 +1965,12 @@ int gfs2_freedi(struct gfs2_sbd *sdp, uint64_t diblock)
/* inode_put deallocated the extra block used by the disk inode, */
/* so adjust it in the superblock struct */
sdp->blks_alloced--;
- rgd->rg.rg_free++;
- rgd->rg.rg_dinodes--;
+ rgd->rt_free++;
+ rgd->rt_dinodes--;
if (sdp->gfs1)
- gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_gfs_rgrp_out(rgd, rgd->bits[0].bi_data);
else
- gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_data);
+ lgfs2_rgrp_out(rgd, rgd->bits[0].bi_data);
rgd->bits[0].bi_modified = 1;
sdp->dinodes_alloced--;
return 0;
diff --git a/gfs2/libgfs2/gfs1.c b/gfs2/libgfs2/gfs1.c
index 6f74ce4d..d1b54a92 100644
--- a/gfs2/libgfs2/gfs1.c
+++ b/gfs2/libgfs2/gfs1.c
@@ -336,6 +336,20 @@ void gfs_rgrp_in(struct gfs_rgrp *rgrp, const char *buf)
memcpy(rgrp->rg_reserved, str->rg_reserved, 64);
}
+void lgfs2_gfs_rgrp_in(const lgfs2_rgrp_t rg, void *buf)
+{
+ struct gfs_rgrp *r = buf;
+
+ rg->rt_flags = be32_to_cpu(r->rg_flags);
+ rg->rt_free = be32_to_cpu(r->rg_free);
+ rg->rt_useddi = be32_to_cpu(r->rg_useddi);
+ rg->rt_freedi = be32_to_cpu(r->rg_freedi);
+ rg->rt_freedi_list.no_formal_ino = be64_to_cpu(r->rg_freedi_list.no_formal_ino);
+ rg->rt_freedi_list.no_addr = be64_to_cpu(r->rg_freedi_list.no_addr);
+ rg->rt_usedmeta = be32_to_cpu(r->rg_usedmeta);
+ rg->rt_freemeta = be32_to_cpu(r->rg_freemeta);
+}
+
void gfs_rgrp_out(const struct gfs_rgrp *rgrp, char *buf)
{
struct gfs_rgrp *str = (struct gfs_rgrp *)buf;
@@ -351,3 +365,21 @@ void gfs_rgrp_out(const struct gfs_rgrp *rgrp, char *buf)
memcpy(str->rg_reserved, rgrp->rg_reserved, 64);
}
+
+void lgfs2_gfs_rgrp_out(const lgfs2_rgrp_t rg, void *buf)
+{
+ struct gfs_rgrp *r = buf;
+
+ r->rg_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
+ r->rg_header.mh_type = cpu_to_be32(GFS2_METATYPE_RG);
+ r->rg_header.mh_format = cpu_to_be32(GFS2_FORMAT_RG);
+ r->rg_flags = cpu_to_be32(rg->rt_flags);
+ r->rg_free = cpu_to_be32(rg->rt_free);
+ r->rg_useddi = cpu_to_be32(rg->rt_useddi);
+ r->rg_freedi = cpu_to_be32(rg->rt_freedi);
+ r->rg_freedi_list.no_formal_ino = cpu_to_be64(rg->rt_freedi_list.no_formal_ino);
+ r->rg_freedi_list.no_addr = cpu_to_be64(rg->rt_freedi_list.no_addr);
+ r->rg_usedmeta = cpu_to_be32(rg->rt_usedmeta);
+ r->rg_freemeta = cpu_to_be32(rg->rt_freemeta);
+
+}
diff --git a/gfs2/libgfs2/lang.c b/gfs2/libgfs2/lang.c
index da35b990..3387df57 100644
--- a/gfs2/libgfs2/lang.c
+++ b/gfs2/libgfs2/lang.c
@@ -236,7 +236,7 @@ static uint64_t ast_lookup_rgrp(uint64_t rgnum, struct gfs2_sbd *sbd)
for (n = osi_first(&sbd->rgtree); n != NULL && i > 0; n = osi_next(n),
i--);
if (n != NULL && i == 0)
- return ((struct rgrp_tree *)n)->ri.ri_addr;
+ return ((struct rgrp_tree *)n)->rt_addr;
fprintf(stderr, "Resource group number out of range: %"PRIu64"\n",
rgnum);
return 0;
}
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index cefb60c8..91f2dcf6 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -177,11 +177,40 @@ struct rgrp_tree {
struct osi_node node;
uint64_t start; /* The offset of the beginning of this resource group */
uint64_t length; /* The length of this resource group */
-
- struct gfs2_rindex ri;
- struct gfs2_rgrp rg;
struct gfs2_bitmap *bits;
lgfs2_rgrps_t rgrps;
+
+ /* Native-endian counterparts of the on-disk rindex struct */
+ uint64_t rt_addr;
+ uint64_t rt_data0;
+ uint32_t rt_data;
+ uint32_t rt_length;
+ uint32_t rt_bitbytes;
+ /* These 3 fields are duplicated between the rindex and the rgrp */
+ /* For now, duplicate them here too, until users can be reworked */
+ uint64_t rt_rg_data0;
+ uint32_t rt_rg_data;
+ uint32_t rt_rg_bitbytes;
+ /* Native-endian counterparts of the on-disk rgrp structs */
+ uint32_t rt_flags;
+ uint32_t rt_free;
+ union {
+ struct { /* gfs2 */
+ uint64_t rt_igeneration;
+ uint32_t rt_dinodes;
+ uint32_t rt_skip;
+ };
+ struct { /* gfs1 */
+ uint32_t rt_useddi;
+ uint32_t rt_freedi;
+ struct {
+ uint64_t no_formal_ino;
+ uint64_t no_addr;
+ } rt_freedi_list;
+ uint32_t rt_usedmeta;
+ uint32_t rt_freemeta;
+ };
+ };
};
typedef struct rgrp_tree *lgfs2_rgrp_t;
@@ -190,7 +219,7 @@ extern lgfs2_rgrps_t lgfs2_rgrps_init(struct gfs2_sbd *sdp, uint64_t
align, uint
extern void lgfs2_rgrps_free(lgfs2_rgrps_t *rgs);
extern uint64_t lgfs2_rindex_entry_new(lgfs2_rgrps_t rgs, struct gfs2_rindex *entry,
uint64_t addr, uint32_t len);
extern unsigned lgfs2_rindex_read_fd(int fd, lgfs2_rgrps_t rgs);
-extern const struct gfs2_rindex *lgfs2_rindex_read_one(struct gfs2_inode *rip,
lgfs2_rgrps_t rgs, unsigned i);
+extern lgfs2_rgrp_t lgfs2_rindex_read_one(struct gfs2_inode *rip, lgfs2_rgrps_t rgs,
unsigned i);
extern uint64_t lgfs2_rgrp_align_addr(const lgfs2_rgrps_t rgs, uint64_t addr);
extern uint32_t lgfs2_rgrp_align_len(const lgfs2_rgrps_t rgs, uint32_t len);
extern unsigned lgfs2_rgsize_for_data(uint64_t blksreq, unsigned bsize);
@@ -200,8 +229,6 @@ extern int lgfs2_rgrp_bitbuf_alloc(lgfs2_rgrp_t rg);
extern void lgfs2_rgrp_bitbuf_free(lgfs2_rgrp_t rg);
extern int lgfs2_rgrp_write(int fd, lgfs2_rgrp_t rg);
extern int lgfs2_rgrps_write_final(int fd, lgfs2_rgrps_t rgs);
-extern const struct gfs2_rindex *lgfs2_rgrp_index(lgfs2_rgrp_t rg);
-extern const struct gfs2_rgrp *lgfs2_rgrp_rgrp(lgfs2_rgrp_t rg);
extern lgfs2_rgrp_t lgfs2_rgrp_first(lgfs2_rgrps_t rgs);
extern lgfs2_rgrp_t lgfs2_rgrp_last(lgfs2_rgrps_t rgs);
extern lgfs2_rgrp_t lgfs2_rgrp_next(lgfs2_rgrp_t rg);
@@ -666,7 +693,9 @@ extern struct gfs2_inode *lgfs2_gfs_inode_get(struct gfs2_sbd *sdp,
char *buf);
extern struct gfs2_inode *lgfs2_gfs_inode_read(struct gfs2_sbd *sdp, uint64_t di_addr);
extern void gfs_jindex_in(struct gfs_jindex *jindex, char *buf);
extern void gfs_rgrp_in(struct gfs_rgrp *rg, const char *buf);
+extern void lgfs2_gfs_rgrp_in(const lgfs2_rgrp_t rg, void *buf);
extern void gfs_rgrp_out(const struct gfs_rgrp *rg, char *buf);
+extern void lgfs2_gfs_rgrp_out(const lgfs2_rgrp_t rg, void *buf);
/* misc.c */
extern int compute_heightsize(unsigned bsize, uint64_t *heightsize,
@@ -702,7 +731,7 @@ 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->ri.ri_data + rgrp->ri.ri_length;
+ return rgrp->rt_data + rgrp->rt_length;
}
/* structures.c */
@@ -747,10 +776,10 @@ extern void gfs2_meta_header_in(struct gfs2_meta_header *mh, const
char *buf);
extern void gfs2_meta_header_out(const struct gfs2_meta_header *mh, char *buf);
extern void gfs2_sb_in(struct gfs2_sb *sb, char *buf);
extern void gfs2_sb_out(const struct gfs2_sb *sb, char *buf);
-extern void gfs2_rindex_in(struct gfs2_rindex *ri, char *buf);
-extern void gfs2_rindex_out(const struct gfs2_rindex *ri, char *buf);
-extern void gfs2_rgrp_in(struct gfs2_rgrp *rg, char *buf);
-extern void gfs2_rgrp_out(const struct gfs2_rgrp *rg, char *buf);
+extern void lgfs2_rindex_in(lgfs2_rgrp_t rg, void *buf);
+extern void lgfs2_rindex_out(const lgfs2_rgrp_t rg, void *buf);
+extern void lgfs2_rgrp_in(lgfs2_rgrp_t rg, void *buf);
+extern void lgfs2_rgrp_out(const lgfs2_rgrp_t rg, void *buf);
extern void lgfs2_dinode_in(struct gfs2_inode *ip, char *buf);
extern void lgfs2_dinode_out(struct gfs2_inode *ip, char *buf);
extern void gfs2_dirent_in(struct gfs2_dirent *de, char *buf);
@@ -762,7 +791,6 @@ extern void gfs2_leaf_out(struct gfs2_leaf *lf, char *buf);
extern void gfs2_inum_print(const struct gfs2_inum *no);
extern void gfs2_meta_header_print(const struct gfs2_meta_header *mh);
-extern void gfs2_rindex_print(const struct gfs2_rindex *ri);
/* These expect on-disk data instead of native-endian structs */
extern void lgfs2_inum_print(void *nop);
extern void lgfs2_meta_header_print(void *mhp);
@@ -775,6 +803,7 @@ extern void lgfs2_quota_change_print(void *qcp);
extern void lgfs2_statfs_change_print(void *scp);
extern void lgfs2_ea_header_print(void *eap);
extern void lgfs2_leaf_print(void *lfp);
+extern void lgfs2_rindex_print(void *rip);
extern void lgfs2_rgrp_print(void *rgp);
__END_DECLS
diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c
index 59b78c3c..f44b76ee 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -185,77 +185,68 @@ void lgfs2_sb_print(void *sbp)
print_it(" uuid", "%36s", NULL, readable_uuid);
}
-void gfs2_rindex_in(struct gfs2_rindex *ri, char *buf)
+void lgfs2_rindex_in(lgfs2_rgrp_t rg, void *buf)
{
- struct gfs2_rindex *str = (struct gfs2_rindex *)buf;
-
- CPIN_64(ri, str, ri_addr);
- CPIN_32(ri, str, ri_length);
- CPIN_32(ri, str, __pad);
- CPIN_64(ri, str, ri_data0);
- CPIN_32(ri, str, ri_data);
- CPIN_32(ri, str, ri_bitbytes);
- CPIN_08(ri, str, ri_reserved, sizeof(ri->ri_reserved));
+ struct gfs2_rindex *ri = buf;
+
+ rg->rt_addr = be64_to_cpu(ri->ri_addr);
+ rg->rt_length = be32_to_cpu(ri->ri_length);
+ rg->rt_data0 = be64_to_cpu(ri->ri_data0);
+ rg->rt_data = be32_to_cpu(ri->ri_data);
+ rg->rt_bitbytes = be32_to_cpu(ri->ri_bitbytes);
}
-void gfs2_rindex_out(const struct gfs2_rindex *ri, char *buf)
+void lgfs2_rindex_out(const lgfs2_rgrp_t rg, void *buf)
{
- struct gfs2_rindex *str = (struct gfs2_rindex *)buf;
-
- CPOUT_64(ri, str, ri_addr);
- CPOUT_32(ri, str, ri_length);
- str->__pad = 0;
-
- CPOUT_64(ri, str, ri_data0);
- CPOUT_32(ri, str, ri_data);
+ struct gfs2_rindex *ri = buf;
- CPOUT_32(ri, str, ri_bitbytes);
-
- CPOUT_08(ri, str, ri_reserved, sizeof(ri->ri_reserved));
+ ri->ri_addr = cpu_to_be64(rg->rt_addr);
+ ri->ri_length = cpu_to_be32(rg->rt_length);
+ ri->ri_data0 = cpu_to_be64(rg->rt_data0);
+ ri->ri_data = cpu_to_be32(rg->rt_data);
+ ri->ri_bitbytes = cpu_to_be32(rg->rt_bitbytes);
}
-void gfs2_rindex_print(const struct gfs2_rindex *ri)
+void lgfs2_rindex_print(void *rip)
{
- pv(ri, ri_addr, "%"PRIu64, "0x%"PRIx64);
- pv(ri, ri_length, "%"PRIu32, "0x%"PRIx32);
-
- pv(ri, ri_data0, "%"PRIu64, "0x%"PRIx64);
- pv(ri, ri_data, "%"PRIu32, "0x%"PRIx32);
+ struct gfs2_rindex *ri = rip;
- pv(ri, ri_bitbytes, "%"PRIu32, "0x%"PRIx32);
+ printbe64(ri, ri_addr);
+ printbe32(ri, ri_length);
+ printbe64(ri, ri_data0);
+ printbe32(ri, ri_data);
+ printbe32(ri, ri_bitbytes);
}
-void gfs2_rgrp_in(struct gfs2_rgrp *rg, char *buf)
+void lgfs2_rgrp_in(lgfs2_rgrp_t rg, void *buf)
{
- struct gfs2_rgrp *str = (struct gfs2_rgrp *)buf;
-
- gfs2_meta_header_in(&rg->rg_header, buf);
- CPIN_32(rg, str, rg_flags);
- CPIN_32(rg, str, rg_free);
- CPIN_32(rg, str, rg_dinodes);
- CPIN_32(rg, str, rg_skip);
- CPIN_64(rg, str, rg_igeneration);
- CPIN_64(rg, str, rg_data0);
- CPIN_32(rg, str, rg_data);
- CPIN_32(rg, str, rg_bitbytes);
- CPIN_32(rg, str, rg_crc);
- CPIN_08(rg, str, rg_reserved, sizeof(rg->rg_reserved));
+ struct gfs2_rgrp *r = buf;
+
+ rg->rt_flags = be32_to_cpu(r->rg_flags);
+ rg->rt_free = be32_to_cpu(r->rg_free);
+ rg->rt_dinodes = be32_to_cpu(r->rg_dinodes);
+ rg->rt_skip = be32_to_cpu(r->rg_skip);
+ rg->rt_igeneration = be64_to_cpu(r->rg_igeneration);
+ rg->rt_rg_data0 = be64_to_cpu(r->rg_data0);
+ rg->rt_rg_data = be32_to_cpu(r->rg_data);
+ rg->rt_rg_bitbytes = be32_to_cpu(r->rg_bitbytes);
}
-void gfs2_rgrp_out(const struct gfs2_rgrp *rg, char *buf)
+void lgfs2_rgrp_out(const lgfs2_rgrp_t rg, void *buf)
{
- struct gfs2_rgrp *str = (struct gfs2_rgrp *)buf;
-
- gfs2_meta_header_out(&rg->rg_header, buf);
- CPOUT_32(rg, str, rg_flags);
- CPOUT_32(rg, str, rg_free);
- CPOUT_32(rg, str, rg_dinodes);
- CPOUT_32(rg, str, rg_skip);
- CPOUT_64(rg, str, rg_igeneration);
- CPOUT_64(rg, str, rg_data0);
- CPOUT_32(rg, str, rg_data);
- CPOUT_32(rg, str, rg_bitbytes);
- CPOUT_08(rg, str, rg_reserved, sizeof(rg->rg_reserved));
+ struct gfs2_rgrp *r = buf;
+
+ r->rg_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
+ r->rg_header.mh_type = cpu_to_be32(GFS2_METATYPE_RG);
+ r->rg_header.mh_format = cpu_to_be32(GFS2_FORMAT_RG);
+ r->rg_flags = cpu_to_be32(rg->rt_flags);
+ r->rg_free = cpu_to_be32(rg->rt_free);
+ r->rg_dinodes = cpu_to_be32(rg->rt_dinodes);
+ r->rg_skip = cpu_to_be32(rg->rt_skip);
+ r->rg_igeneration = cpu_to_be64(rg->rt_igeneration);
+ r->rg_data0 = cpu_to_be64(rg->rt_rg_data0);
+ r->rg_data = cpu_to_be32(rg->rt_rg_data);
+ r->rg_bitbytes = cpu_to_be32(rg->rt_rg_bitbytes);
lgfs2_rgrp_crc_set(buf);
}
diff --git a/gfs2/libgfs2/rgrp.c b/gfs2/libgfs2/rgrp.c
index aa5eadf2..96789ff4 100644
--- a/gfs2/libgfs2/rgrp.c
+++ b/gfs2/libgfs2/rgrp.c
@@ -20,13 +20,13 @@ static void compute_bitmaps(lgfs2_rgrp_t rg, const unsigned bsize)
rg->bits[0].bi_start = 0;
rg->bits[0].bi_len = bsize - sizeof(struct gfs2_rgrp);
- for (x = 1; x < rg->ri.ri_length; x++) {
+ for (x = 1; x < rg->rt_length; x++) {
rg->bits[x].bi_offset = sizeof(struct gfs2_meta_header);
rg->bits[x].bi_start = rg->bits[x - 1].bi_start + rg->bits[x - 1].bi_len;
rg->bits[x].bi_len = bsize - sizeof(struct gfs2_meta_header);
}
x--;
- rg->bits[x].bi_len = rg->ri.ri_bitbytes - rg->bits[x].bi_start;
+ rg->bits[x].bi_len = rg->rt_bitbytes - rg->bits[x].bi_start;
}
/**
@@ -37,7 +37,7 @@ static void compute_bitmaps(lgfs2_rgrp_t rg, const unsigned bsize)
*/
int gfs2_compute_bitstructs(const uint32_t bsize, struct rgrp_tree *rgd)
{
- uint32_t length = rgd->ri.ri_length;
+ uint32_t length = rgd->rt_length;
uint32_t bytes_left;
int ownbits = 0;
@@ -59,14 +59,14 @@ int gfs2_compute_bitstructs(const uint32_t bsize, struct rgrp_tree
*rgd)
}
compute_bitmaps(rgd, bsize);
- bytes_left = rgd->ri.ri_bitbytes - (rgd->bits[rgd->ri.ri_length - 1].bi_start
+
- rgd->bits[rgd->ri.ri_length - 1].bi_len);
+ bytes_left = rgd->rt_bitbytes - (rgd->bits[rgd->rt_length - 1].bi_start +
+ rgd->bits[rgd->rt_length - 1].bi_len);
errno = EINVAL;
if(bytes_left)
goto errbits;
if((rgd->bits[length - 1].bi_start +
- rgd->bits[length - 1].bi_len) * GFS2_NBBY != rgd->ri.ri_data)
+ rgd->bits[length - 1].bi_len) * GFS2_NBBY != rgd->rt_data)
goto errbits;
return 0;
@@ -90,9 +90,9 @@ struct rgrp_tree *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, uint64_t blk)
{
struct rgrp_tree *rgd = (struct rgrp_tree *)sdp->rgtree.osi_node;
while (rgd) {
- if (blk < rgd->ri.ri_addr)
+ if (blk < rgd->rt_addr)
rgd = (struct rgrp_tree *)rgd->node.osi_left;
- else if (blk >= rgd->ri.ri_data0 + rgd->ri.ri_data)
+ else if (blk >= rgd->rt_data0 + rgd->rt_data)
rgd = (struct rgrp_tree *)rgd->node.osi_right;
else
return rgd;
@@ -109,7 +109,7 @@ struct rgrp_tree *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, uint64_t blk)
int lgfs2_rgrp_bitbuf_alloc(lgfs2_rgrp_t rg)
{
struct gfs2_sbd *sdp = rg->rgrps->sdp;
- size_t len = rg->ri.ri_length * sdp->bsize;
+ size_t len = rg->rt_length * sdp->bsize;
unsigned long io_align = sdp->bsize;
unsigned i;
char *bufs;
@@ -124,7 +124,7 @@ int lgfs2_rgrp_bitbuf_alloc(lgfs2_rgrp_t rg)
}
memset(bufs, 0, len);
- for (i = 0; i < rg->ri.ri_length; i++) {
+ for (i = 0; i < rg->rt_length; i++) {
rg->bits[i].bi_data = bufs + (i * sdp->bsize);
rg->bits[i].bi_modified = 0;
}
@@ -143,7 +143,7 @@ void lgfs2_rgrp_bitbuf_free(lgfs2_rgrp_t rg)
unsigned i;
free(rg->bits[0].bi_data);
- for (i = 0; i < rg->ri.ri_length; i++) {
+ for (i = 0; i < rg->rt_length; i++) {
rg->bits[i].bi_data = NULL;
rg->bits[i].bi_modified = 0;
}
@@ -189,11 +189,11 @@ void lgfs2_rgrp_crc_set(char *buf)
*/
uint64_t gfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
{
- unsigned length = rgd->ri.ri_length * sdp->bsize;
- off_t offset = rgd->ri.ri_addr * sdp->bsize;
+ unsigned length = rgd->rt_length * sdp->bsize;
+ off_t offset = rgd->rt_addr * sdp->bsize;
char *buf;
- if (length == 0 || gfs2_check_range(sdp, rgd->ri.ri_addr))
+ if (length == 0 || gfs2_check_range(sdp, rgd->rt_addr))
return -1;
buf = calloc(1, length);
@@ -205,23 +205,24 @@ uint64_t gfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree
*rgd)
return -1;
}
- for (unsigned i = 0; i < rgd->ri.ri_length; i++) {
+ for (unsigned i = 0; i < rgd->rt_length; i++) {
int mtype = (i ? GFS2_METATYPE_RB : GFS2_METATYPE_RG);
rgd->bits[i].bi_data = buf + (i * sdp->bsize);
if (gfs2_check_meta(rgd->bits[i].bi_data, mtype)) {
free(buf);
- return rgd->ri.ri_addr + i;
+ rgd->bits[0].bi_data = NULL;
+ return rgd->rt_addr + i;
}
}
if (sdp->gfs1)
- gfs_rgrp_in((struct gfs_rgrp *)&rgd->rg, buf);
+ lgfs2_gfs_rgrp_in(rgd, buf);
else {
if (lgfs2_rgrp_crc_check(buf)) {
free(buf);
- return rgd->ri.ri_addr;
+ return rgd->rt_addr;
}
- gfs2_rgrp_in(&rgd->rg, buf);
+ lgfs2_rgrp_in(rgd, buf);
}
return 0;
}
@@ -230,8 +231,8 @@ void gfs2_rgrp_relse(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
{
if (rgd->bits == NULL)
return;
- for (unsigned i = 0; i < rgd->ri.ri_length; i++) {
- off_t offset = sdp->bsize * (rgd->ri.ri_addr + i);
+ for (unsigned i = 0; i < rgd->rt_length; i++) {
+ off_t offset = sdp->bsize * (rgd->rt_addr + i);
ssize_t ret;
if (rgd->bits[i].bi_data == NULL || !rgd->bits[i].bi_modified)
@@ -240,12 +241,12 @@ void gfs2_rgrp_relse(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
ret = pwrite(sdp->device_fd, rgd->bits[i].bi_data, sdp->bsize, offset);
if (ret != sdp->bsize) {
fprintf(stderr, "Failed to write modified resource group at block
%"PRIu64": %s\n",
- (uint64_t)rgd->ri.ri_addr, strerror(errno));
+ rgd->rt_addr, strerror(errno));
}
rgd->bits[i].bi_modified = 0;
}
free(rgd->bits[0].bi_data);
- for (unsigned i = 0; i < rgd->ri.ri_length; i++)
+ for (unsigned i = 0; i < rgd->rt_length; i++)
rgd->bits[i].bi_data = NULL;
}
@@ -259,9 +260,9 @@ struct rgrp_tree *rgrp_insert(struct osi_root *rgtree, uint64_t
rgblock)
struct rgrp_tree *cur = (struct rgrp_tree *)*newn;
parent = *newn;
- if (rgblock < cur->ri.ri_addr)
+ if (rgblock < cur->rt_addr)
newn = &((*newn)->osi_left);
- else if (rgblock > cur->ri.ri_addr)
+ else if (rgblock > cur->rt_addr)
newn = &((*newn)->osi_right);
else
return cur;
@@ -271,7 +272,7 @@ struct rgrp_tree *rgrp_insert(struct osi_root *rgtree, uint64_t
rgblock)
if (!data)
return NULL;
/* Add new node and rebalance tree. */
- data->ri.ri_addr = rgblock;
+ data->rt_addr = rgblock;
osi_link_node(&data->node, parent, newn);
osi_insert_color(&data->node, rgtree);
@@ -440,7 +441,6 @@ lgfs2_rgrps_t lgfs2_rgrps_init(struct gfs2_sbd *sdp, uint64_t align,
uint64_t of
unsigned lgfs2_rindex_read_fd(int fd, lgfs2_rgrps_t rgs)
{
unsigned count = 0;
- char buf[sizeof(struct gfs2_rindex)];
errno = EINVAL;
if (fd < 0 || rgs == NULL)
@@ -449,14 +449,13 @@ unsigned lgfs2_rindex_read_fd(int fd, lgfs2_rgrps_t rgs)
while (1) {
lgfs2_rgrp_t rg;
struct gfs2_rindex ri;
- ssize_t ret = read(fd, buf, sizeof(struct gfs2_rindex));
+ ssize_t ret = read(fd, &ri, sizeof(ri));
if (ret == 0)
break;
- if (ret != sizeof(struct gfs2_rindex))
+ if (ret != sizeof(ri))
return 0;
- gfs2_rindex_in(&ri, buf);
rg = lgfs2_rgrps_append(rgs, &ri, 0);
if (rg == NULL)
return 0;
@@ -473,10 +472,9 @@ unsigned lgfs2_rindex_read_fd(int fd, lgfs2_rgrps_t rgs)
* Returns the new rindex entry added to the set or NULL on error with errno
* set.
*/
-const struct gfs2_rindex *lgfs2_rindex_read_one(struct gfs2_inode *rip, lgfs2_rgrps_t
rgs, unsigned i)
+lgfs2_rgrp_t lgfs2_rindex_read_one(struct gfs2_inode *rip, lgfs2_rgrps_t rgs, unsigned
i)
{
uint64_t off = i * sizeof(struct gfs2_rindex);
- char buf[sizeof(struct gfs2_rindex)];
struct gfs2_rindex ri;
lgfs2_rgrp_t rg;
int ret;
@@ -485,16 +483,15 @@ const struct gfs2_rindex *lgfs2_rindex_read_one(struct gfs2_inode
*rip, lgfs2_rg
if (rip == NULL || rgs == NULL)
return NULL;
- ret = gfs2_readi(rip, buf, off, sizeof(struct gfs2_rindex));
+ ret = gfs2_readi(rip, &ri, off, sizeof(struct gfs2_rindex));
if (ret != sizeof(struct gfs2_rindex))
return NULL;
- gfs2_rindex_in(&ri, buf);
rg = lgfs2_rgrps_append(rgs, &ri, 0);
if (rg == NULL)
return NULL;
- return &rg->ri;
+ return rg;
}
/**
@@ -510,7 +507,7 @@ void lgfs2_rgrps_free(lgfs2_rgrps_t *rgs)
while ((rg = (struct rgrp_tree *)osi_first(tree))) {
int i;
free(rg->bits[0].bi_data);
- for (i = 0; i < rg->ri.ri_length; i++) {
+ for (i = 0; i < rg->rt_length; i++) {
rg->bits[i].bi_data = NULL;
}
osi_erase(&rg->node, tree);
@@ -560,6 +557,7 @@ uint32_t rgblocks2bitblocks(const unsigned int bsize, const uint32_t
rgblocks, u
uint64_t lgfs2_rindex_entry_new(lgfs2_rgrps_t rgs, struct gfs2_rindex *ri, uint64_t addr,
uint32_t len)
{
struct rg_spec *spec = rgs->plan->rg_specs;
+ uint32_t ri_length, ri_data;
int plan = -1;
errno = EINVAL;
if (!ri)
@@ -581,34 +579,16 @@ 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->ri_addr = addr;
- ri->ri_length = rgblocks2bitblocks(rgs->sdp->bsize, len, &ri->ri_data);
+ ri_length = rgblocks2bitblocks(rgs->sdp->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);
ri->__pad = 0;
- ri->ri_data0 = ri->ri_addr + ri->ri_length;
- ri->ri_bitbytes = ri->ri_data / GFS2_NBBY;
+ ri->ri_data0 = cpu_to_be64(addr + ri_length);
+ ri->ri_bitbytes = cpu_to_be32(ri_data / GFS2_NBBY);
memset(&ri->ri_reserved, 0, sizeof(ri->ri_reserved));
- return ri->ri_addr + len;
-}
-
-/**
- * Return the rindex structure relating to a resource group.
- * The return type is const to advise callers that making changes to this
- * structure directly isn't wise. libgfs2 functions should be used instead.
- */
-const struct gfs2_rindex *lgfs2_rgrp_index(lgfs2_rgrp_t rg)
-{
- return &rg->ri;
-}
-
-/**
- * Return the rgrp structure relating to a resource group.
- * The return type is const to advise callers that making changes to this
- * structure directly isn't wise. libgfs2 functions should be used instead.
- */
-const struct gfs2_rgrp *lgfs2_rgrp_rgrp(lgfs2_rgrp_t rg)
-{
- return &rg->rg;
+ return addr + len;
}
/**
@@ -650,12 +630,12 @@ lgfs2_rgrp_t lgfs2_rgrps_append(lgfs2_rgrps_t rgs, struct
gfs2_rindex *entry, ui
return NULL;
if (lastrg != NULL) { /* Tree is not empty */
- if (entry->ri_addr <= lastrg->ri.ri_addr)
+ if (be64_to_cpu(entry->ri_addr) <= lastrg->rt_addr)
return NULL; /* Appending with a lower address doesn't make sense */
link = &lastrg->node.osi_right;
}
- rg = calloc(1, sizeof(*rg) + (entry->ri_length * sizeof(struct gfs2_bitmap)));
+ rg = calloc(1, sizeof(*rg) + (be32_to_cpu(entry->ri_length) * sizeof(struct
gfs2_bitmap)));
if (rg == NULL)
return NULL;
@@ -664,16 +644,16 @@ lgfs2_rgrp_t lgfs2_rgrps_append(lgfs2_rgrps_t rgs, struct
gfs2_rindex *entry, ui
osi_link_node(&rg->node, parent, link);
osi_insert_color(&rg->node, &rgs->root);
- memcpy(&rg->ri, entry, sizeof(struct gfs2_rindex));
- rg->rg.rg_header.mh_magic = GFS2_MAGIC;
- rg->rg.rg_header.mh_type = GFS2_METATYPE_RG;
- rg->rg.rg_header.mh_format = GFS2_FORMAT_RG;
- rg->rg.rg_free = rg->ri.ri_data;
- rg->rg.rg_skip = rg_skip;
- rg->rg.rg_data0 = rg->ri.ri_data0;
- rg->rg.rg_data = rg->ri.ri_data;
- rg->rg.rg_bitbytes = rg->ri.ri_bitbytes;
- rg->rg.rg_crc = 0;
+ rg->rt_addr = be64_to_cpu(entry->ri_addr);
+ rg->rt_length = be32_to_cpu(entry->ri_length);
+ rg->rt_data0 = be64_to_cpu(entry->ri_data0);
+ rg->rt_data = be32_to_cpu(entry->ri_data);
+ rg->rt_bitbytes = be32_to_cpu(entry->ri_bitbytes);
+ rg->rt_flags = 0;
+ rg->rt_free = be32_to_cpu(entry->ri_data);
+ rg->rt_dinodes = 0;
+ rg->rt_skip = rg_skip;
+ rg->rt_igeneration = 0;
compute_bitmaps(rg, rgs->sdp->bsize);
rg->rgrps = rgs;
return rg;
@@ -687,11 +667,6 @@ int lgfs2_rgrp_write(int fd, const lgfs2_rgrp_t rg)
{
struct gfs2_sbd *sdp = rg->rgrps->sdp;
unsigned int i;
- const struct gfs2_meta_header bmh = {
- .mh_magic = GFS2_MAGIC,
- .mh_type = GFS2_METATYPE_RB,
- .mh_format = GFS2_FORMAT_RB,
- };
int freebufs = 0;
ssize_t ret;
size_t len;
@@ -701,16 +676,20 @@ int lgfs2_rgrp_write(int fd, const lgfs2_rgrp_t rg)
if (lgfs2_rgrp_bitbuf_alloc(rg) != 0)
return -1;
}
- gfs2_rgrp_out(&rg->rg, rg->bits[0].bi_data);
- for (i = 1; i < rg->ri.ri_length; i++) {
- gfs2_meta_header_out(&bmh, rg->bits[i].bi_data);
+ lgfs2_rgrp_out(rg, rg->bits[0].bi_data);
+ for (i = 1; i < rg->rt_length; i++) {
+ struct gfs2_meta_header *mh = (void *)rg->bits[i].bi_data;
+
+ mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
+ mh->mh_type = cpu_to_be32(GFS2_METATYPE_RB);
+ mh->mh_format = cpu_to_be32(GFS2_FORMAT_RB);
}
- len = sdp->bsize * rg->ri.ri_length;
+ len = sdp->bsize * rg->rt_length;
if (rg->rgrps->align > 0)
len = ROUND_UP(len, rg->rgrps->align * sdp->bsize);
- ret = pwrite(fd, rg->bits[0].bi_data, len, rg->ri.ri_addr * sdp->bsize);
+ ret = pwrite(fd, rg->bits[0].bi_data, len, rg->rt_addr * sdp->bsize);
if (freebufs)
lgfs2_rgrp_bitbuf_free(rg);
@@ -729,7 +708,7 @@ int lgfs2_rgrps_write_final(int fd, lgfs2_rgrps_t rgs)
{
lgfs2_rgrp_t rg = lgfs2_rgrp_last(rgs);
- rg->rg.rg_skip = 0;
+ rg->rt_skip = 0;
if (lgfs2_rgrp_write(fd, rg) != 0)
return -1;
return 0;
@@ -769,14 +748,14 @@ lgfs2_rgrp_t lgfs2_rgrp_last(lgfs2_rgrps_t rgs)
*/
int lgfs2_rbm_from_block(struct lgfs2_rbm *rbm, uint64_t block)
{
- uint64_t rblock = block - rbm->rgd->ri.ri_data0;
+ uint64_t rblock = block - rbm->rgd->rt_data0;
struct gfs2_sbd *sdp = rbm->rgd->rgrps->sdp;
if (rblock > UINT_MAX) {
errno = EINVAL;
return 1;
}
- if (block >= rbm->rgd->ri.ri_data0 + rbm->rgd->ri.ri_data) {
+ if (block >= rbm->rgd->rt_data0 + rbm->rgd->rt_data) {
errno = E2BIG;
return 1;
}
@@ -812,7 +791,7 @@ static int lgfs2_rbm_incr(struct lgfs2_rbm *rbm)
rbm->offset++;
return 0;
}
- if (rbm->bii == rbm->rgd->ri.ri_length - 1) /* at the last bitmap */
+ if (rbm->bii == rbm->rgd->rt_length - 1) /* at the last bitmap */
return 1;
rbm->offset = 0;
@@ -953,7 +932,7 @@ int lgfs2_rbm_find(struct lgfs2_rbm *rbm, uint8_t state, uint32_t
*minext)
int initial_bii;
uint32_t offset;
int n = 0;
- int iters = rbm->rgd->ri.ri_length;
+ int iters = rbm->rgd->rt_length;
uint32_t extlen;
/* If we are not starting at the beginning of a bitmap, then we
@@ -969,7 +948,7 @@ int lgfs2_rbm_find(struct lgfs2_rbm *rbm, uint8_t state, uint32_t
*minext)
uint64_t block;
int ret;
- if ((rbm->rgd->rg.rg_free < *minext) && (state == GFS2_BLKST_FREE))
+ if ((rbm->rgd->rt_free < *minext) && (state == GFS2_BLKST_FREE))
goto next_bitmap;
offset = gfs2_bitfit(buf, bi->bi_len, rbm->offset, state);
@@ -1005,7 +984,7 @@ int lgfs2_rbm_find(struct lgfs2_rbm *rbm, uint8_t state, uint32_t
*minext)
next_bitmap: /* Find next bitmap in the rgrp */
rbm->offset = 0;
rbm->bii++;
- if (rbm->bii == rbm->rgd->ri.ri_length)
+ if (rbm->bii == rbm->rgd->rt_length)
rbm->bii = 0;
res_covered_end_of_rgrp:
diff --git a/gfs2/libgfs2/rgrp.h b/gfs2/libgfs2/rgrp.h
index ed5c7358..386ade3d 100644
--- a/gfs2/libgfs2/rgrp.h
+++ b/gfs2/libgfs2/rgrp.h
@@ -41,7 +41,7 @@ static inline struct gfs2_bitmap *rbm_bi(const struct lgfs2_rbm *rbm)
static inline uint64_t lgfs2_rbm_to_block(const struct lgfs2_rbm *rbm)
{
- return rbm->rgd->ri.ri_data0 + (rbm_bi(rbm)->bi_start * GFS2_NBBY) +
+ return rbm->rgd->rt_data0 + (rbm_bi(rbm)->bi_start * GFS2_NBBY) +
rbm->offset;
}
diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c
index 562640f7..e900a7df 100644
--- a/gfs2/libgfs2/structures.c
+++ b/gfs2/libgfs2/structures.c
@@ -520,7 +520,7 @@ int build_rindex(struct gfs2_sbd *sdp)
next = osi_next(n);
rl = (struct rgrp_tree *)n;
- gfs2_rindex_out(&rl->ri, buf);
+ lgfs2_rindex_out(rl, buf);
count = gfs2_writei(ip, buf, ip->i_size, sizeof(struct gfs2_rindex));
if (count != sizeof(struct gfs2_rindex))
@@ -663,7 +663,7 @@ unsigned lgfs2_bm_scan(struct rgrp_tree *rgd, unsigned idx, uint64_t
*buf, uint8
bi->bi_len, blk, state);
if (blk == BFITNOENT)
break;
- buf[n++] = blk + (bi->bi_start * GFS2_NBBY) + rgd->ri.ri_data0;
+ buf[n++] = blk + (bi->bi_start * GFS2_NBBY) + rgd->rt_data0;
blk++;
}
return n;
diff --git a/gfs2/libgfs2/super.c b/gfs2/libgfs2/super.c
index e8ade2e2..f304b4df 100644
--- a/gfs2/libgfs2/super.c
+++ b/gfs2/libgfs2/super.c
@@ -147,20 +147,20 @@ static int rgd_seems_ok(struct gfs2_sbd *sdp, struct rgrp_tree
*rgd)
uint32_t most_bitmaps_possible;
/* rg length must be at least 1 */
- if (rgd->ri.ri_length == 0)
+ if (rgd->rt_length == 0)
return 0;
/* A max rgrp, 2GB, divided into blocksize, divided by blocks/byte
represented in the bitmap, NBBY. Rough approximation only, due to
metadata headers. I'm doing the math this way to avoid overflow. */
most_bitmaps_possible = (GFS2_MAX_RGSIZE * 1024 * 256) / sdp->bsize;
- if (rgd->ri.ri_length > most_bitmaps_possible)
+ if (rgd->rt_length > most_bitmaps_possible)
return 0;
- if (rgd->ri.ri_data0 != rgd->ri.ri_addr + rgd->ri.ri_length)
+ if (rgd->rt_data0 != rgd->rt_addr + rgd->rt_length)
return 0;
- if (rgd->ri.ri_bitbytes != rgd->ri.ri_data / GFS2_NBBY)
+ if (rgd->rt_bitbytes != rgd->rt_data / GFS2_NBBY)
return 0;
return 1;
@@ -180,7 +180,7 @@ static int good_on_disk(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
struct gfs2_buffer_head *bh;
int is_rgrp;
- bh = bread(sdp, rgd->ri.ri_addr);
+ bh = bread(sdp, rgd->rt_addr);
is_rgrp = (gfs2_check_meta(bh->b_data, GFS2_METATYPE_RG) == 0);
brelse(bh);
return is_rgrp;
@@ -198,10 +198,6 @@ int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount, int *ok)
{
unsigned int rg;
int error;
- union {
- struct gfs2_rindex bufgfs2;
- } buf;
- struct gfs2_rindex ri;
struct rgrp_tree *rgd = NULL, *prev_rgd = NULL;
uint64_t prev_length = 0;
@@ -210,7 +206,10 @@ int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount, int *ok)
if (sdp->md.riinode->i_size % sizeof(struct gfs2_rindex))
*ok = 0; /* rindex file size must be a multiple of 96 */
for (rg = 0; ; rg++) {
- error = gfs2_readi(sdp->md.riinode, (char *)&buf.bufgfs2,
+ struct gfs2_rindex ri;
+ uint64_t addr;
+
+ error = gfs2_readi(sdp->md.riinode, &ri,
rg * sizeof(struct gfs2_rindex),
sizeof(struct gfs2_rindex));
if (!error)
@@ -218,17 +217,19 @@ int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount, int *ok)
if (error != sizeof(struct gfs2_rindex))
return -1;
- gfs2_rindex_in(&ri, (char *)&buf.bufgfs2);
- if (gfs2_check_range(sdp, ri.ri_addr) != 0) {
+ addr = be64_to_cpu(ri.ri_addr);
+ if (gfs2_check_range(sdp, addr) != 0) {
*ok = 0;
if (prev_rgd == NULL)
continue;
- ri.ri_addr = prev_rgd->ri.ri_addr + prev_rgd->length;
+ addr = prev_rgd->rt_addr + prev_rgd->length;
}
- rgd = rgrp_insert(&sdp->rgtree, ri.ri_addr);
- memcpy(&rgd->ri, &ri, sizeof(struct gfs2_rindex));
-
- rgd->start = rgd->ri.ri_addr;
+ rgd = 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);
+ rgd->rt_bitbytes = be32_to_cpu(ri.ri_bitbytes);
+ rgd->start = addr;
if (prev_rgd) {
/* If rg addresses go backwards, it's not sane
(or it's converted from gfs1). */
diff --git a/gfs2/mkfs/main_grow.c b/gfs2/mkfs/main_grow.c
index 2fadd06a..deb9230d 100644
--- a/gfs2/mkfs/main_grow.c
+++ b/gfs2/mkfs/main_grow.c
@@ -194,8 +194,10 @@ static lgfs2_rgrps_t rgrps_init(struct gfs2_sbd *sdp)
static uint64_t filesystem_size(lgfs2_rgrps_t rgs)
{
lgfs2_rgrp_t rg = lgfs2_rgrp_last(rgs);
- const struct gfs2_rindex *ri = lgfs2_rgrp_index(rg);
- return ri->ri_data0 + ri->ri_data;
+ struct gfs2_rindex ri;
+
+ lgfs2_rindex_out(rg, &ri);
+ return be64_to_cpu(ri.ri_data0) + be32_to_cpu(ri.ri_data);
}
/**
@@ -253,8 +255,7 @@ static char *rindex_buffer(lgfs2_rgrps_t rgs, unsigned count)
exit(EXIT_FAILURE);
}
for (rg = lgfs2_rgrp_first(rgs); rg; rg = lgfs2_rgrp_next(rg)) {
- const struct gfs2_rindex *ri = lgfs2_rgrp_index(rg);
- gfs2_rindex_out(ri, buf + (sizeof(*ri) * i));
+ lgfs2_rindex_out(rg, buf + (sizeof(struct gfs2_rindex) * i));
i++;
}
return buf;
diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c
index 32211db7..6374ebc7 100644
--- a/gfs2/mkfs/main_mkfs.c
+++ b/gfs2/mkfs/main_mkfs.c
@@ -771,16 +771,21 @@ static lgfs2_rgrps_t rgs_init(struct mkfs_opts *opts, struct
gfs2_sbd *sdp)
static int place_rgrp(struct gfs2_sbd *sdp, lgfs2_rgrp_t rg, int debug)
{
uint64_t prev_end = (GFS2_SB_ADDR * GFS2_BASIC_BLOCK / sdp->bsize) + 1;
- const struct gfs2_rindex *ri = lgfs2_rgrp_index(rg);
lgfs2_rgrp_t prev = lgfs2_rgrp_prev(rg);
+ struct gfs2_rindex ri;
+ uint64_t addr;
int err = 0;
if (prev != NULL) {
- prev_end = lgfs2_rgrp_index(prev)->ri_data0 +
- lgfs2_rgrp_index(prev)->ri_data;
+ lgfs2_rindex_out(prev, &ri);
+ prev_end = be64_to_cpu(ri.ri_data0) + be32_to_cpu(ri.ri_data);
}
- while (prev_end < ri->ri_addr) {
- size_t gap_len = ri->ri_addr - prev_end;
+
+ lgfs2_rindex_out(rg, &ri);
+ addr = be64_to_cpu(ri.ri_addr);
+
+ while (prev_end < addr) {
+ size_t gap_len = addr - prev_end;
if (gap_len > IOV_MAX)
gap_len = IOV_MAX;
@@ -795,11 +800,11 @@ static int place_rgrp(struct gfs2_sbd *sdp, lgfs2_rgrp_t rg, int
debug)
return -1;
}
if (debug) {
- gfs2_rindex_print(ri);
+ lgfs2_rindex_print(&ri);
printf("\n");
}
- sdp->blks_total += ri->ri_data;
- sdp->fssize = ri->ri_data0 + ri->ri_data;
+ sdp->blks_total += be32_to_cpu(ri.ri_data);
+ sdp->fssize = be64_to_cpu(ri.ri_data0) + be32_to_cpu(ri.ri_data);
sdp->rgrps++;
return 0;
}
@@ -849,6 +854,7 @@ static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs,
struct mkfs_o
int result;
lgfs2_rgrp_t rg;
struct gfs2_inode in = {0};
+ struct gfs2_rindex ri;
gfs2_progress_update(&progress, (j + 1));
@@ -867,7 +873,8 @@ static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs,
struct mkfs_o
return result;
}
/* Allocate at the beginning of the rgrp, bypassing extent search */
- in.i_addr = lgfs2_rgrp_index(rg)->ri_data0;
+ lgfs2_rindex_out(rg, &ri);
+ in.i_addr = be64_to_cpu(ri.ri_data0);
/* In order to keep writes sequential here, we have to allocate
the journal, then write the rgrp header (which is now in its
final form) and then write the journal out */
diff --git a/tests/nukerg.c b/tests/nukerg.c
index f323d643..3bca919c 100644
--- a/tests/nukerg.c
+++ b/tests/nukerg.c
@@ -186,11 +186,12 @@ static int nuke_rgs(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs,
unsigned *rgnums, s
memset(&blankrg, 0, sizeof(blankrg));
for (rg = lgfs2_rgrp_first(rgs), i = 0; rg; rg = lgfs2_rgrp_next(rg), i++) {
- const struct gfs2_rindex *ri = lgfs2_rgrp_index(rg);
+ struct gfs2_rindex ri;
unsigned j;
+ lgfs2_rindex_out(rg, &ri);
for (j = 0; j < count; j++) {
- uint64_t addr = ri->ri_addr;
+ uint64_t addr = be64_to_cpu(ri.ri_addr);
off_t off = addr * sdp->bsize;
ssize_t bytes;
@@ -262,10 +263,10 @@ static lgfs2_rgrps_t read_rindex(struct gfs2_sbd *sdp)
}
rgcount = sdp->md.riinode->i_size / sizeof(struct gfs2_rindex);
for (i = 0; i < rgcount; i++) {
- const struct gfs2_rindex *ri;
+ lgfs2_rgrp_t rg;
- ri = lgfs2_rindex_read_one(sdp->md.riinode, rgs, i);
- if (ri == NULL) {
+ rg = lgfs2_rindex_read_one(sdp->md.riinode, rgs, i);
+ if (rg == NULL) {
fprintf(stderr, "Failed to read rindex entry %u: %s\n",
i, strerror(errno));
return NULL;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.