[gfs2-utils] 22/40: libgfs2: Remove some now-unused functions
by pagure＠pagure.io
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 454a9e6839b879438c4778f85109a19f768b5c95
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Thu May 20 18:07:29 2021 +0100
libgfs2: Remove some now-unused functions
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/libgfs2/gfs1.c | 32 --------------------------------
gfs2/libgfs2/libgfs2.h | 8 +-------
gfs2/libgfs2/ondisk.c | 13 -------------
3 files changed, 1 insertion(+), 52 deletions(-)
diff --git a/gfs2/libgfs2/gfs1.c b/gfs2/libgfs2/gfs1.c
index 4cdf26e5..97fa32a5 100644
--- a/gfs2/libgfs2/gfs1.c
+++ b/gfs2/libgfs2/gfs1.c
@@ -320,22 +320,6 @@ void gfs_jindex_in(struct gfs_jindex *jindex, char *jbuf)
memcpy(jindex->ji_reserved, str->ji_reserved, 64);
}
-void gfs_rgrp_in(struct gfs_rgrp *rgrp, const char *buf)
-{
- struct gfs_rgrp *str = (struct gfs_rgrp *)buf;
-
- gfs2_meta_header_in(&rgrp->rg_header, buf);
- rgrp->rg_flags = be32_to_cpu(str->rg_flags);
- rgrp->rg_free = be32_to_cpu(str->rg_free);
- rgrp->rg_useddi = be32_to_cpu(str->rg_useddi);
- rgrp->rg_freedi = be32_to_cpu(str->rg_freedi);
- gfs2_inum_in(&rgrp->rg_freedi_list, (char *)&str->rg_freedi_list);
- rgrp->rg_usedmeta = be32_to_cpu(str->rg_usedmeta);
- rgrp->rg_freemeta = be32_to_cpu(str->rg_freemeta);
-
- 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;
@@ -350,22 +334,6 @@ void lgfs2_gfs_rgrp_in(const lgfs2_rgrp_t rg, void *buf)
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;
-
- gfs2_meta_header_out(&rgrp->rg_header, buf);
- str->rg_flags = cpu_to_be32(rgrp->rg_flags);
- str->rg_free = cpu_to_be32(rgrp->rg_free);
- str->rg_useddi = cpu_to_be32(rgrp->rg_useddi);
- str->rg_freedi = cpu_to_be32(rgrp->rg_freedi);
- gfs2_inum_out(&rgrp->rg_freedi_list, (char *)&str->rg_freedi_list);
- str->rg_usedmeta = cpu_to_be32(rgrp->rg_usedmeta);
- str->rg_freemeta = cpu_to_be32(rgrp->rg_freemeta);
-
- 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;
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index 49250fab..7fae35c3 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -702,9 +702,7 @@ extern int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
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 */
@@ -796,11 +794,7 @@ extern void gfs2_dirent_out(struct gfs2_dirent *de, char *buf);
extern void gfs2_leaf_in(struct gfs2_leaf *lf, char *buf);
extern void gfs2_leaf_out(struct gfs2_leaf *lf, char *buf);
-/* Printing functions */
-
-extern void gfs2_inum_print(const struct gfs2_inum *no);
-extern void gfs2_meta_header_print(const struct gfs2_meta_header *mh);
-/* These expect on-disk data instead of native-endian structs */
+/* Printing functions. These expect on-disk data */
extern void lgfs2_inum_print(void *nop);
extern void lgfs2_meta_header_print(void *mhp);
extern void lgfs2_sb_print(void *sbp);
diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c
index a1805234..77798993 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -67,12 +67,6 @@ void gfs2_inum_out(const struct gfs2_inum *no, char *buf)
CPOUT_64(no, str, no_addr);
}
-void gfs2_inum_print(const struct gfs2_inum *no)
-{
- pv(no, no_formal_ino, "%"PRIu64, "0x%"PRIx64);
- pv(no, no_addr, "%"PRIu64, "0x%"PRIx64);
-}
-
void lgfs2_inum_print(void *nop)
{
struct gfs2_inum *no = nop;
@@ -101,13 +95,6 @@ void gfs2_meta_header_out(const struct gfs2_meta_header *mh, char *buf)
str->__pad1 = 0;
}
-void gfs2_meta_header_print(const struct gfs2_meta_header *mh)
-{
- pv(mh, mh_magic, "0x%08"PRIX32, NULL);
- pv(mh, mh_type, "%"PRIu32, "0x%"PRIx32);
- pv(mh, mh_format, "%"PRIu32, "0x%"PRIx32);
-}
-
void lgfs2_meta_header_print(void *mhp)
{
struct gfs2_meta_header *mh = mhp;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
- 1
- 0
[gfs2-utils] 21/40: libgfs2: Remove sd_sb from struct gfs2_sbd
by pagure＠pagure.io
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 767016aa71e640fa4709113fbed84887aabe985b
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Thu May 20 18:01:10 2021 +0100
libgfs2: Remove sd_sb from struct gfs2_sbd
Replace it with native-endian counterparts of the on-disk structures.
Adding fields for the gfs1-specific fields means that some gfs1-specific
variables can be removed. Update the _in() and _out() functions to work
with a gfs2_sbd instead of the big-endian gfs2_sb.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/convert/gfs2_convert.c | 166 +++++++++++++++++++---------------------
gfs2/edit/extended.c | 14 ++--
gfs2/edit/gfs2hex.c | 11 ++-
gfs2/edit/hexedit.c | 147 +++++++++++++++++-------------------
gfs2/edit/hexedit.h | 1 -
gfs2/edit/journal.c | 38 +++++-----
gfs2/edit/savemeta.c | 104 +++++++++++++------------
gfs2/fsck/afterpass1_common.c | 2 +-
gfs2/fsck/fs_recovery.c | 18 ++---
gfs2/fsck/fsck.h | 1 -
gfs2/fsck/initialize.c | 167 +++++++++++++++++------------------------
gfs2/fsck/metawalk.c | 42 +++++------
gfs2/fsck/metawalk.h | 2 +-
gfs2/fsck/pass1.c | 16 ++--
gfs2/fsck/pass2.c | 8 +-
gfs2/fsck/rgrepair.c | 38 +++++-----
gfs2/fsck/util.c | 4 +-
gfs2/glocktop/glocktop.c | 14 ++--
gfs2/libgfs2/buf.c | 12 +--
gfs2/libgfs2/check_rgrp.c | 4 +-
gfs2/libgfs2/device_geometry.c | 2 +-
gfs2/libgfs2/fs_ops.c | 52 ++++++-------
gfs2/libgfs2/gfs1.c | 14 ++--
gfs2/libgfs2/gfs2l.c | 4 +-
gfs2/libgfs2/lang.c | 12 +--
gfs2/libgfs2/libgfs2.h | 38 +++++++---
gfs2/libgfs2/misc.c | 22 +++---
gfs2/libgfs2/ondisk.c | 91 +++++++++++-----------
gfs2/libgfs2/recovery.c | 12 +--
gfs2/libgfs2/rgrp.c | 38 +++++-----
gfs2/libgfs2/structures.c | 52 +++++--------
gfs2/libgfs2/super.c | 58 +++++++-------
gfs2/mkfs/main_grow.c | 18 ++---
gfs2/mkfs/main_jadd.c | 28 +++----
gfs2/mkfs/main_mkfs.c | 84 +++++++++++----------
tests/nukerg.c | 7 +-
36 files changed, 646 insertions(+), 695 deletions(-)
diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c
index 280eac42..c8ebfe3b 100644
--- a/gfs2/convert/gfs2_convert.c
+++ b/gfs2/convert/gfs2_convert.c
@@ -35,8 +35,8 @@
/* The following declares are needed because gfs2 can't have */
/* dependencies on gfs1: */
-#define RGRP_STUFFED_BLKS(sb) (((sb)->sb_bsize - sizeof(struct gfs2_rgrp)) * GFS2_NBBY)
-#define RGRP_BITMAP_BLKS(sb) (((sb)->sb_bsize - sizeof(struct gfs2_meta_header)) * GFS2_NBBY)
+#define RGRP_STUFFED_BLKS(bsize) (((bsize) - sizeof(struct gfs2_rgrp)) * GFS2_NBBY)
+#define RGRP_BITMAP_BLKS(bsize) (((bsize) - sizeof(struct gfs2_meta_header)) * GFS2_NBBY)
/* Define some gfs1 constants from gfs1's gfs_ondisk.h */
#define GFS_METATYPE_NONE (0)
@@ -94,7 +94,7 @@ struct gfs2_options {
unsigned int query:1;
};
-struct gfs_sb raw_gfs1_ondisk_sb;
+struct gfs_sb gfs1_sb;
struct gfs2_sbd sb2;
struct inode_block dirs_to_fix; /* linked list of directories to fix */
struct inode_dir_block cdpns_to_fix; /* linked list of cdpn symlinks */
@@ -143,7 +143,7 @@ static void convert_bitmaps(struct gfs2_sbd *sdp, struct rgrp_tree *rg)
sizeof(struct gfs2_rgrp);
bi = &rg->bits[blk];
- for (; x < sdp->bsize; x++)
+ for (; x < sdp->sd_bsize; x++)
for (y = 0; y < GFS2_NBBY; y++) {
state = (bi->bi_data[x] >> (GFS2_BIT_SIZE * y)) & 0x03;
if (state == 0x02) {/* unallocated metadata state invalid */
@@ -303,7 +303,7 @@ static void fix_metatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
bh = bread(sbp, block);
if (new)
- memset(bh->b_data, 0, sbp->bsize);
+ memset(bh->b_data, 0, sbp->sd_bsize);
gfs2_meta_header_out(&mh, bh->b_data);
bmodified(bh);
}
@@ -311,8 +311,8 @@ static void fix_metatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
hdrsize = blk->height ? sizeof(struct gfs2_meta_header) :
sizeof(struct gfs2_dinode);
- if (amount > sbp->bsize - hdrsize - ptramt)
- amount = sbp->bsize - hdrsize - ptramt;
+ if (amount > sbp->sd_bsize - hdrsize - ptramt)
+ amount = sbp->sd_bsize - hdrsize - ptramt;
memcpy(bh->b_data + hdrsize + ptramt, (char *)srcptr, amount);
srcptr += amount;
@@ -322,7 +322,7 @@ static void fix_metatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
copied += amount;
- if (hdrsize + ptramt + amount >= sbp->bsize) {
+ if (hdrsize + ptramt + amount >= sbp->sd_bsize) {
/* advance to the next metablock */
blk->mp.mp_list[blk->height] +=
(amount / sizeof(uint64_t));
@@ -400,14 +400,14 @@ static void jdata_mp_gfs1_to_gfs2(struct gfs2_sbd *sbp, int gfs1_h, int gfs2_h,
/* figure out multiplication factors for each height - gfs1 */
memset(&gfs1factor, 0, sizeof(gfs1factor));
- gfs1factor[gfs1_h - 1] = sbp->bsize - sizeof(struct gfs2_meta_header);
+ gfs1factor[gfs1_h - 1] = sbp->sd_bsize - sizeof(struct gfs2_meta_header);
for (h = gfs1_h - 1; h > 0; h--)
gfs1factor[h - 1] = gfs1factor[h] * sbp->sd_inptrs;
/* figure out multiplication factors for each height - gfs2 */
memset(&gfs2factor, 0, sizeof(gfs2factor));
gfs2factor[gfs2_h] = 1ull;
- gfs2factor[gfs2_h - 1] = sbp->bsize;
+ gfs2factor[gfs2_h - 1] = sbp->sd_bsize;
for (h = gfs2_h - 1; h > 0; h--)
gfs2factor[h - 1] = gfs2factor[h] * gfs2_inptrs;
@@ -461,15 +461,15 @@ static uint64_t fix_jdatatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
bh = bread(sbp, block);
if (new)
- memset(bh->b_data, 0, sbp->bsize);
+ memset(bh->b_data, 0, sbp->sd_bsize);
if (h < (blk->height - 1)) {
gfs2_meta_header_out(&mh, bh->b_data);
bmodified(bh);
}
}
- if (amount > sbp->bsize - ptramt)
- amount = sbp->bsize - ptramt;
+ if (amount > sbp->sd_bsize - ptramt)
+ amount = sbp->sd_bsize - ptramt;
memcpy(bh->b_data + ptramt, (char *)srcptr, amount);
srcptr += amount;
@@ -479,7 +479,7 @@ static uint64_t fix_jdatatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
copied += amount;
- if (ptramt + amount >= sbp->bsize) {
+ if (ptramt + amount >= sbp->sd_bsize) {
/* advance to the next metablock */
blk->mp.mp_list[blk->height] += amount;
for (h = blk->height; h > 0; h--) {
@@ -504,7 +504,7 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip, str
osi_list_t *tmp;
uint64_t *ptr1, block;
int h, ptrnum;
- int bufsize = sbp->bsize - sizeof(struct gfs_indirect);
+ int bufsize = sbp->sd_bsize - sizeof(struct gfs_indirect);
/* Add dinode block to the list */
blk = malloc(sizeof(struct blocklist));
@@ -524,10 +524,10 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip, str
memset(blk->ptrbuf, 0, bufsize);
/* Fill in the pointers from the dinode buffer */
memcpy(blk->ptrbuf, dibh->b_data + sizeof(struct gfs_dinode),
- sbp->bsize - sizeof(struct gfs_dinode));
+ sbp->sd_bsize - sizeof(struct gfs_dinode));
/* Zero out the pointers so we can fill them in later. */
memset(dibh->b_data + sizeof(struct gfs_dinode), 0,
- sbp->bsize - sizeof(struct gfs_dinode));
+ sbp->sd_bsize - sizeof(struct gfs_dinode));
osi_list_add_prev(&blk->list, &blocks->list);
/* Now run the metadata chain and build lists of all metadata blocks */
@@ -588,7 +588,7 @@ static int fix_ind_reg_or_dir(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint3
int ptrnum;
struct metapath gfs2mp;
- bufsize = sbp->bsize - sizeof(struct gfs_indirect);
+ bufsize = sbp->sd_bsize - sizeof(struct gfs_indirect);
len = bufsize;
/* Skip zero pointers at the start of the buffer. This may
@@ -634,7 +634,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint32_t d
struct metapath gfs2mp;
struct gfs2_buffer_head *bh;
- bufsize = sbp->bsize - sizeof(struct gfs2_meta_header);
+ bufsize = sbp->sd_bsize - sizeof(struct gfs2_meta_header);
/*
* For each metadata block that holds jdata block pointers,
* get the blk pointers and copy them block by block
@@ -828,7 +828,7 @@ static int fix_xattr(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, struct g
/* Read in the i_eattr block */
eabh = bread(sbp, ip->i_eattr);
if (!gfs2_check_meta(eabh->b_data, GFS_METATYPE_IN)) {/* if it is an indirect block */
- len = sbp->bsize - sizeof(struct gfs_indirect);
+ len = sbp->sd_bsize - sizeof(struct gfs_indirect);
buf = malloc(len);
if (!buf) {
/*FIXME: Same message as fix_cdpn_symlink */
@@ -837,8 +837,8 @@ static int fix_xattr(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, struct g
}
old_hdr_sz = sizeof(struct gfs_indirect);
new_hdr_sz = sizeof(struct gfs2_meta_header);
- memcpy(buf, eabh->b_data + old_hdr_sz, sbp->bsize - old_hdr_sz);
- memset(eabh->b_data + new_hdr_sz, 0, sbp->bsize - new_hdr_sz);
+ memcpy(buf, eabh->b_data + old_hdr_sz, sbp->sd_bsize - old_hdr_sz);
+ memset(eabh->b_data + new_hdr_sz, 0, sbp->sd_bsize - new_hdr_sz);
memcpy(eabh->b_data + new_hdr_sz, buf, len);
free(buf);
bmodified(eabh);
@@ -1058,8 +1058,8 @@ static int inode_renumber(struct gfs2_sbd *sbp, uint64_t root_inode_addr, osi_li
break;
/* If this is the root inode block, remember it for later: */
if (block == root_inode_addr) {
- sbp->sd_sb.sb_root_dir.no_addr = block;
- sbp->sd_sb.sb_root_dir.no_formal_ino = sbp->md.next_inum;
+ sbp->sd_root_dir.no_addr = block;
+ sbp->sd_root_dir.no_formal_ino = sbp->md.next_inum;
}
bh = bread(sbp, block);
if (!gfs2_check_meta(bh->b_data, GFS_METATYPE_DI)) {/* if it is an dinode */
@@ -1085,7 +1085,7 @@ static int inode_renumber(struct gfs2_sbd *sbp, uint64_t root_inode_addr, osi_li
buf_offset = (blk) ? sizeof(struct gfs2_meta_header) :
sizeof(struct gfs2_rgrp);
/* if it's on this page */
- if (buf_offset + bitmap_byte < sbp->bsize) {
+ if (buf_offset + bitmap_byte < sbp->sd_bsize) {
bi->bi_data[buf_offset + bitmap_byte] &=
~(0x03 << (GFS2_BIT_SIZE * byte_bit));
bi->bi_data[buf_offset + bitmap_byte] |=
@@ -1093,7 +1093,7 @@ static int inode_renumber(struct gfs2_sbd *sbp, uint64_t root_inode_addr, osi_li
bi->bi_modified = 1;
break;
}
- bitmap_byte -= (sbp->bsize - buf_offset);
+ bitmap_byte -= (sbp->sd_bsize - buf_offset);
}
}
brelse(bh);
@@ -1346,7 +1346,7 @@ static int fix_directory_info(struct gfs2_sbd *sbp, osi_list_t *dir_to_fix)
uint64_t dirblock;
uint32_t gfs1_inptrs = sbp->sd_inptrs;
/* Directory inodes have been converted to gfs2, use gfs2 inptrs */
- sbp->sd_inptrs = (sbp->bsize - sizeof(struct gfs2_meta_header))
+ sbp->sd_inptrs = (sbp->sd_bsize - sizeof(struct gfs2_meta_header))
/ sizeof(uint64_t);
dirs_fixed = 0;
@@ -1500,7 +1500,7 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
}
journ = sd_jindex + j;
gfs1_jindex_in(journ, buf);
- sdp->jsize = (journ->ji_nsegment * 16 * sdp->bsize) >> 20;
+ sdp->jsize = (journ->ji_nsegment * 16 * sdp->sd_bsize) >> 20;
}
ip->i_mode = tmp_mode;
if(j * sizeof(struct gfs_jindex) != ip->i_size){
@@ -1518,15 +1518,15 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
static int sanity_check(struct gfs2_sbd *sdp)
{
int error = 0;
- if (!raw_gfs1_ondisk_sb.sb_quota_di.no_addr) {
+ if (!gfs1_sb.sb_quota_di.no_addr) {
log_crit(_("Error: Superblock Quota inode address is NULL\n"));
error = 1;
}
- if (!raw_gfs1_ondisk_sb.sb_license_di.no_addr) {
+ if (!gfs1_sb.sb_license_di.no_addr) {
log_crit(_("Error: Superblock Statfs inode address is NULL\n"));
error = 1;
}
- if (!raw_gfs1_ondisk_sb.sb_seg_size) {
+ if (!gfs1_sb.sb_seg_size) {
log_crit(_("Error: Superblock segment size is zero\n"));
error = 1;
}
@@ -1595,13 +1595,6 @@ static int init(struct gfs2_sbd *sbp, struct gfs2_options *opts)
perror(opts->device);
exit(-1);
}
- /* --------------------------------- */
- /* initialize the incore superblock */
- /* --------------------------------- */
- sbp->sd_sb.sb_header.mh_magic = GFS2_MAGIC;
- sbp->sd_sb.sb_header.mh_type = GFS2_METATYPE_SB;
- sbp->sd_sb.sb_header.mh_format = GFS2_FORMAT_SB;
-
osi_list_init((osi_list_t *)&dirs_to_fix);
osi_list_init((osi_list_t *)&cdpns_to_fix);
/* ---------------------------------------------- */
@@ -1614,8 +1607,7 @@ static int init(struct gfs2_sbd *sbp, struct gfs2_options *opts)
sbp->blks_total = 0; /* total blocks - total them up later */
sbp->blks_alloced = 0; /* blocks allocated - total them up later */
sbp->dinodes_alloced = 0; /* dinodes allocated - total them up later */
- sbp->sd_sb.sb_bsize = GFS2_DEFAULT_BSIZE;
- sbp->bsize = sbp->sd_sb.sb_bsize;
+ sbp->sd_bsize = GFS2_DEFAULT_BSIZE;
sbp->rgtree.osi_node = NULL;
if (compute_constants(sbp)) {
log_crit("%s\n", _("Failed to compute file system constants"));
@@ -1623,28 +1615,27 @@ static int init(struct gfs2_sbd *sbp, struct gfs2_options *opts)
}
bh = bread(sbp, GFS2_SB_ADDR >> sbp->sd_fsb2bb_shift);
- memcpy(&raw_gfs1_ondisk_sb, (struct gfs_sb *)bh->b_data,
- sizeof(struct gfs_sb));
- gfs2_sb_in(&sbp->sd_sb, bh->b_data);
+ memcpy(&gfs1_sb, bh->b_data, sizeof(struct gfs_sb));
+ lgfs2_sb_in(sbp, bh->b_data);
- jindex_addr = be64_to_cpu(raw_gfs1_ondisk_sb.sb_jindex_di.no_addr);
- rindex_addr = be64_to_cpu(raw_gfs1_ondisk_sb.sb_rindex_di.no_addr);
+ jindex_addr = be64_to_cpu(gfs1_sb.sb_jindex_di.no_addr);
+ rindex_addr = be64_to_cpu(gfs1_sb.sb_rindex_di.no_addr);
- sbp->bsize = sbp->sd_sb.sb_bsize;
- sbp->fssize = lseek(sbp->device_fd, 0, SEEK_END) / sbp->sd_sb.sb_bsize;
- sbp->sd_inptrs = (sbp->bsize - sizeof(struct gfs_indirect)) /
+ sbp->sd_bsize = sbp->sd_bsize;
+ sbp->fssize = lseek(sbp->device_fd, 0, SEEK_END) / sbp->sd_bsize;
+ sbp->sd_inptrs = (sbp->sd_bsize - sizeof(struct gfs_indirect)) /
sizeof(uint64_t);
- sbp->sd_diptrs = (sbp->bsize - sizeof(struct gfs_dinode)) /
+ sbp->sd_diptrs = (sbp->sd_bsize - sizeof(struct gfs_dinode)) /
sizeof(uint64_t);
- sbp->sd_jbsize = sbp->bsize - sizeof(struct gfs2_meta_header);
+ sbp->sd_jbsize = sbp->sd_bsize - sizeof(struct gfs2_meta_header);
brelse(bh);
- if (compute_heightsize(sbp->bsize, sbp->sd_heightsize, &sbp->sd_max_height,
- sbp->bsize, sbp->sd_diptrs, sbp->sd_inptrs)) {
+ if (compute_heightsize(sbp->sd_bsize, sbp->sd_heightsize, &sbp->sd_max_height,
+ sbp->sd_bsize, sbp->sd_diptrs, sbp->sd_inptrs)) {
log_crit("%s\n", _("Failed to compute file system constants"));
exit(-1);
}
- if (compute_heightsize(sbp->bsize, sbp->sd_jheightsize, &sbp->sd_max_jheight,
+ if (compute_heightsize(sbp->sd_bsize, sbp->sd_jheightsize, &sbp->sd_max_jheight,
sbp->sd_jbsize, sbp->sd_diptrs, sbp->sd_inptrs)) {
log_crit("%s\n", _("Failed to compute file system constants"));
exit(-1);
@@ -1652,41 +1643,38 @@ static int init(struct gfs2_sbd *sbp, struct gfs2_options *opts)
/* -------------------------------------------------------- */
/* Our constants are for gfs1. Need some for gfs2 as well. */
/* -------------------------------------------------------- */
- gfs2_inptrs = (sbp->bsize - sizeof(struct gfs2_meta_header)) /
+ gfs2_inptrs = (sbp->sd_bsize - sizeof(struct gfs2_meta_header)) /
sizeof(uint64_t); /* How many ptrs can we fit on a block? */
memset(gfs2_heightsize, 0, sizeof(gfs2_heightsize));
- if (compute_heightsize(sbp->bsize, gfs2_heightsize, &gfs2_max_height,
- sbp->bsize, sbp->sd_diptrs, gfs2_inptrs)) {
+ if (compute_heightsize(sbp->sd_bsize, gfs2_heightsize, &gfs2_max_height,
+ sbp->sd_bsize, sbp->sd_diptrs, gfs2_inptrs)) {
log_crit("%s\n", _("Failed to compute file system constants"));
exit(-1);
}
memset(gfs2_jheightsize, 0, sizeof(gfs2_jheightsize));
- if (compute_heightsize(sbp->bsize, gfs2_jheightsize, &gfs2_max_jheight,
+ if (compute_heightsize(sbp->sd_bsize, gfs2_jheightsize, &gfs2_max_jheight,
sbp->sd_jbsize, sbp->sd_diptrs, gfs2_inptrs)) {
log_crit("%s\n", _("Failed to compute file system constants"));
exit(-1);
}
-
- /* ---------------------------------------------- */
- /* Make sure we're really gfs1 */
- /* ---------------------------------------------- */
- if (sbp->sd_sb.sb_fs_format != GFS_FORMAT_FS ||
- sbp->sd_sb.sb_header.mh_type != GFS_METATYPE_SB ||
- sbp->sd_sb.sb_header.mh_format != GFS_FORMAT_SB ||
- sbp->sd_sb.sb_multihost_format != GFS_FORMAT_MULTI) {
+ /* Make sure we're really gfs1 */
+ if (be32_to_cpu(gfs1_sb.sb_fs_format) != GFS_FORMAT_FS ||
+ be32_to_cpu(gfs1_sb.sb_header.mh_type) != GFS_METATYPE_SB ||
+ be32_to_cpu(gfs1_sb.sb_header.mh_format) != GFS_FORMAT_SB ||
+ be32_to_cpu(gfs1_sb.sb_multihost_format) != GFS_FORMAT_MULTI) {
log_crit(_("Error: %s does not look like a gfs1 filesystem.\n"), opts->device);
close(sbp->device_fd);
exit(-1);
}
/* get gfs1 rindex inode - gfs1's rindex inode ptr became __pad2 */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_rindex_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_rindex_di);
sbp->md.riinode = lgfs2_gfs_inode_read(sbp, inum.no_addr);
if (sbp->md.riinode == NULL) {
log_crit(_("Could not read resource group index: %s\n"), strerror(errno));
exit(-1);
}
/* get gfs1 jindex inode - gfs1's journal index inode ptr became master */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_jindex_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_jindex_di);
sbp->md.jiinode = lgfs2_inode_read(sbp, inum.no_addr);
if (sbp->md.jiinode == NULL) {
log_crit(_("Could not read journal index: %s\n"), strerror(errno));
@@ -1813,8 +1801,8 @@ static void process_parameters(int argc, char **argv, struct gfs2_options *opts)
/* ------------------------------------------------------------------------- */
static uint64_t rgrp_length(uint64_t size, struct gfs2_sbd *sdp)
{
- uint64_t bitbytes = RGRP_BITMAP_BLKS(&sdp->sd_sb) + 1;
- uint64_t stuff = RGRP_STUFFED_BLKS(&sdp->sd_sb) + 1;
+ uint64_t bitbytes = RGRP_BITMAP_BLKS(sdp->sd_bsize) + 1;
+ uint64_t stuff = RGRP_STUFFED_BLKS(sdp->sd_bsize) + 1;
uint64_t blocks = 1;
if (size >= stuff) {
@@ -1885,7 +1873,7 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
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);
+ be32_to_cpu(gfs1_sb.sb_seg_size);
rgd->rt_flags = 0;
rgd->rt_dinodes = 0;
@@ -1901,18 +1889,18 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
rgd->rt_free = rgd->rt_data;
rgd->rt_bitbytes = rgd->rt_data / GFS2_NBBY;
- if (gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, rgd)) {
+ if (gfs2_compute_bitstructs(sdp->sd_bsize, rgd)) {
log_crit(_("gfs2_convert: Error converting bitmaps.\n"));
exit(-1);
}
- rgd->bits[0].bi_data = calloc(rgd->rt_length, sdp->bsize);
+ rgd->bits[0].bi_data = calloc(rgd->rt_length, sdp->sd_bsize);
if (rgd->bits[0].bi_data == NULL) {
perror("");
exit(-1);
}
for (unsigned i = 1; i < rgd->rt_length; i++)
- rgd->bits[i].bi_data = rgd->bits[0].bi_data + (i * sdp->bsize);
+ rgd->bits[i].bi_data = rgd->bits[0].bi_data + (i * sdp->sd_bsize);
convert_bitmaps(sdp, rgd);
lgfs2_rgrp_out(rgd, rgd->bits[0].bi_data);
@@ -1975,19 +1963,19 @@ static void remove_obsolete_gfs1(struct gfs2_sbd *sbp)
log_notice(_("Removing obsolete GFS1 file system structures.\n"));
fflush(stdout);
/* Delete the old gfs1 Journal index: */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_jindex_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_jindex_di);
gfs2_freedi(sbp, inum.no_addr);
/* Delete the old gfs1 rgindex: */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_rindex_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_rindex_di);
gfs2_freedi(sbp, inum.no_addr);
/* Delete the old gfs1 Quota file: */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_quota_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_quota_di);
gfs2_freedi(sbp, inum.no_addr);
/* Delete the old gfs1 License file: */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_license_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_license_di);
gfs2_freedi(sbp, inum.no_addr);
}
@@ -2017,8 +2005,8 @@ static int conv_build_jindex(struct gfs2_sbd *sdp)
sprintf(name, "journal%u", j);
sdp->md.journal[j] = createi(sdp->md.jiinode, name, S_IFREG |
0600, GFS2_DIF_SYSTEM);
- write_journal(sdp->md.journal[j], sdp->bsize,
- sdp->jsize << 20 >> sdp->sd_sb.sb_bsize_shift);
+ write_journal(sdp->md.journal[j], sdp->sd_bsize,
+ sdp->jsize << 20 >> sdp->sd_bsize_shift);
inode_put(&sdp->md.journal[j]);
printf(_("done.\n"));
fflush(stdout);
@@ -2037,7 +2025,7 @@ static unsigned int total_file_blocks(struct gfs2_sbd *sdp,
uint64_t *arr;
/* Now find the total meta blocks required for data_blks */
- if (filesize <= sdp->bsize - sizeof(struct gfs2_dinode)) {
+ if (filesize <= sdp->sd_bsize - sizeof(struct gfs2_dinode)) {
goto out;
}
@@ -2048,7 +2036,7 @@ static unsigned int total_file_blocks(struct gfs2_sbd *sdp,
} else {
arr = sdp->sd_heightsize;
max = sdp->sd_max_height;
- bsize = sdp->bsize;
+ bsize = sdp->sd_bsize;
}
data_blks = DIV_RU(filesize, bsize); /* total data blocks reqd */
@@ -2138,7 +2126,7 @@ static void copy_quotas(struct gfs2_sbd *sdp)
exit(1);
}
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_quota_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_quota_di);
oq_ip = lgfs2_inode_read(sdp, inum.no_addr);
if (oq_ip == NULL) {
fprintf(stderr, _("Couldn't lookup old quota file: %s\n"), strerror(errno));
@@ -2150,7 +2138,7 @@ static void copy_quotas(struct gfs2_sbd *sdp)
nq_ip->i_blocks = oq_ip->i_blocks;
memcpy(nq_ip->i_bh->b_data + sizeof(struct gfs2_dinode),
oq_ip->i_bh->b_data + sizeof(struct gfs2_dinode),
- sdp->bsize - sizeof(struct gfs2_dinode));
+ sdp->sd_bsize - sizeof(struct gfs2_dinode));
oq_ip->i_height = 0;
oq_ip->i_size = 0;
@@ -2246,7 +2234,7 @@ int main(int argc, char **argv)
/* ---------------------------------------------- */
if (!error) {
/* Add a string notifying inode converstion start? */
- error = inode_renumber(&sb2, sb2.sd_sb.sb_root_dir.no_addr,
+ error = inode_renumber(&sb2, sb2.sd_root_dir.no_addr,
(osi_list_t *)&cdpns_to_fix);
if (error)
log_crit(_("\n%s: Error renumbering inodes.\n"), opts.device);
@@ -2308,8 +2296,8 @@ int main(int argc, char **argv)
"GFS2 file system structures.\n"), sb2.jsize);
/* Build the master subdirectory. */
build_master(&sb2); /* Does not do inode_put */
- sb2.sd_sb.sb_master_dir.no_addr = sb2.master_dir->i_addr;
- sb2.sd_sb.sb_master_dir.no_formal_ino = sb2.master_dir->i_formal_ino;
+ sb2.sd_meta_dir.no_addr = sb2.master_dir->i_addr;
+ sb2.sd_meta_dir.no_formal_ino = sb2.master_dir->i_formal_ino;
/* Build empty journal index file. */
error = conv_build_jindex(&sb2);
if (error) {
@@ -2384,9 +2372,9 @@ int main(int argc, char **argv)
/* it to not reject the partially converted fs as already done */
/* when it's run a second time. */
bh = bread(&sb2, LGFS2_SB_ADDR(&sb2));
- sb2.sd_sb.sb_fs_format = GFS2_FORMAT_FS;
- sb2.sd_sb.sb_multihost_format = GFS2_FORMAT_MULTI;
- gfs2_sb_out(&sb2.sd_sb, bh->b_data);
+ sb2.sd_fs_format = GFS2_FORMAT_FS;
+ sb2.sd_multihost_format = GFS2_FORMAT_MULTI;
+ lgfs2_sb_out(&sb2, bh->b_data);
bmodified(bh);
brelse(bh);
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index e9e2a7eb..4d6b7496 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -62,7 +62,7 @@ static int _do_indirect_extended(char *diebuf, struct iinfo *iinf, int hgt)
memset(&iinf->ii[x].dirent, 0, sizeof(struct gfs2_dirents));
}
headoff = sbd.gfs1 ? sizeof(struct gfs_indirect) : sizeof(struct gfs2_meta_header);
- for (x = headoff, y = 0; x < sbd.bsize; x += sizeof(uint64_t), y++) {
+ for (x = headoff, y = 0; x < sbd.sd_bsize; x += sizeof(uint64_t), y++) {
p = be64_to_cpu(*(uint64_t *)(diebuf + x));
if (p) {
iinf->ii[i_blocks].block = p;
@@ -196,7 +196,7 @@ static int display_indirect(struct iinfo *ind, int indblocks, int level,
file_offset = metapath_to_lblock(&ind->ii[pndx].mp,
cur_height) *
- sbd.bsize;
+ sbd.sd_bsize;
print_gfs2(" ");
h = 'K';
human_off = (file_offset / 1024.0);
@@ -378,7 +378,7 @@ static void print_block_details(struct iinfo *ind, int level, int cur_height,
"display_indirect\n");
return;
}
- tmpbuf = malloc(sbd.bsize);
+ tmpbuf = malloc(sbd.sd_bsize);
if (!tmpbuf) {
fprintf(stderr, "Out of memory in function "
"display_indirect\n");
@@ -387,7 +387,7 @@ static void print_block_details(struct iinfo *ind, int level, int cur_height,
}
while (thisblk) {
/* read in the desired block */
- if (pread(sbd.device_fd, tmpbuf, sbd.bsize, thisblk * sbd.bsize) != sbd.bsize) {
+ if (pread(sbd.device_fd, tmpbuf, sbd.sd_bsize, thisblk * sbd.sd_bsize) != sbd.sd_bsize) {
fprintf(stderr, "bad read: %s from %s:%d: block %"PRIu64
" (0x%"PRIx64")\n", strerror(errno), __FUNCTION__,
__LINE__, ind->ii[pndx].block, ind->ii[pndx].block);
@@ -543,7 +543,7 @@ static int parse_rindex(struct gfs2_inode *dip, int print_rindex)
struct gfs2_rgrp r = {0};
ssize_t ret;
- ret = pread(sbd.device_fd, &r, sizeof(r), rg.rt_addr * sbd.bsize);
+ ret = pread(sbd.device_fd, &r, sizeof(r), rg.rt_addr * sbd.sd_bsize);
if (ret != sizeof(r)) {
perror("Failed to read resource group");
} else if (sbd.gfs1) {
@@ -646,7 +646,7 @@ int display_extended(void)
brelse(tmp_bh);
} else if (block_is_journals(block)) {
if (sbd.gfs1)
- block = sbd1->sb_jindex_di.no_addr;
+ block = sbd.sd_jindex_di.no_addr;
else
block = masterblock("jindex");
print_gfs2_jindex();
@@ -657,7 +657,7 @@ int display_extended(void)
return -1;
else if (block_is_rgtree(block)) {
if (sbd.gfs1)
- tmp_bh = bread(&sbd, sbd1->sb_rindex_di.no_addr);
+ tmp_bh = bread(&sbd, sbd.sd_rindex_di.no_addr);
else
tmp_bh = bread(&sbd, masterblock("rindex"));
tmp_inode = lgfs2_inode_get(&sbd, tmp_bh);
diff --git a/gfs2/edit/gfs2hex.c b/gfs2/edit/gfs2hex.c
index 092b35b6..f0c409b5 100644
--- a/gfs2/edit/gfs2hex.c
+++ b/gfs2/edit/gfs2hex.c
@@ -46,7 +46,6 @@ struct blkstack_info blockstack[BLOCK_STACK_SIZE];
int identify = FALSE;
uint64_t max_block = 0;
int start_row[DMODES], end_row[DMODES], lines_per_row[DMODES];
-struct gfs_sb *sbd1;
int gfs2_struct_type;
unsigned int offset;
struct indirect_info masterdir;
@@ -246,7 +245,7 @@ void do_dinode_extended(char *buf)
memset(indirect, 0, sizeof(struct iinfo));
if (be16_to_cpu(dip->di_height) > 0) {
/* Indirect pointers */
- for (x = sizeof(struct gfs2_dinode); x < sbd.bsize;
+ for (x = sizeof(struct gfs2_dinode); x < sbd.sd_bsize;
x += sizeof(uint64_t)) {
p = be64_to_cpu(*(uint64_t *)(buf + x));
if (p) {
@@ -268,7 +267,7 @@ void do_dinode_extended(char *buf)
indirect->ii[0].dirents = 0;
indirect->ii[0].block = block;
indirect->ii[0].is_dir = TRUE;
- for (x = sizeof(struct gfs2_dinode); x < sbd.bsize; x += skip) {
+ for (x = sizeof(struct gfs2_dinode); x < sbd.sd_bsize; x += skip) {
skip = indirect_dirent(indirect->ii, buf + x,
indirect->ii[0].dirents);
if (skip <= 0)
@@ -298,7 +297,7 @@ void do_dinode_extended(char *buf)
gfs2_leaf_in(&leaf, tmp_bh->b_data);
indirect->ii[indirect_blocks].dirents = 0;
for (direntcount = 0, bufoffset = sizeof(struct gfs2_leaf);
- bufoffset < sbd.bsize;
+ bufoffset < sbd.sd_bsize;
direntcount++, bufoffset += skip) {
skip = indirect_dirent(&indirect->ii[indirect_blocks],
tmp_bh->b_data + bufoffset,
@@ -327,7 +326,7 @@ uint64_t do_leaf_extended(char *dlebuf, struct iinfo *indir)
memset(indir, 0, sizeof(*indir));
gfs2_leaf_in(&indir->ii[0].lf, dlebuf);
/* Directory Entries: */
- for (i = sizeof(struct gfs2_leaf); i < sbd.bsize;
+ for (i = sizeof(struct gfs2_leaf); i < sbd.sd_bsize;
i += de.de_rec_len) {
gfs2_dirent_in(&de, dlebuf + i);
if (de.de_inum.no_addr) {
@@ -359,7 +358,7 @@ static void do_eattr_extended(char *buf)
print_gfs2("Eattr Entries:");
eol(0);
- for (x = sizeof(struct gfs2_meta_header); x < sbd.bsize; x += rec_len)
+ for (x = sizeof(struct gfs2_meta_header); x < sbd.sd_bsize; x += rec_len)
{
eol(0);
buf += x;
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index 18afd0ed..2843262b 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -347,7 +347,7 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
struct_len = mtype->size;
ret_type = mtype->mh_type;
} else {
- struct_len = sbd.bsize;
+ struct_len = sbd.sd_bsize;
ret_type = 0;
}
}
@@ -376,8 +376,8 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
pgnum = (offset / screen_chunk_size);
if (type >= 0) {
print_gfs2("(p.%d of %d--%s)", pgnum + 1,
- (sbd.bsize % screen_chunk_size) > 0 ?
- sbd.bsize / screen_chunk_size + 1 : sbd.bsize /
+ (sbd.sd_bsize % screen_chunk_size) > 0 ?
+ sbd.sd_bsize / screen_chunk_size + 1 : sbd.sd_bsize /
screen_chunk_size, allocdesc[sbd.gfs1][type]);
}
/*eol(9);*/
@@ -415,7 +415,7 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
struct_len = (b ?
sizeof(struct gfs2_meta_header) :
sizeof(struct gfs2_rgrp));
- blknum += (sbd.bsize - struct_len);
+ blknum += (sbd.sd_bsize - struct_len);
}
struct_len = sizeof(struct gfs2_meta_header);
/* add the number of bytes on this screen */
@@ -439,9 +439,9 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
if (rgd)
gfs2_rgrp_relse(&sbd, rgd);
}
- if (block == sbd.sd_sb.sb_root_dir.no_addr)
+ if (block == sbd.sd_root_dir.no_addr)
print_gfs2("--------------- Root directory ------------------");
- else if (!sbd.gfs1 && block == sbd.sd_sb.sb_master_dir.no_addr)
+ else if (!sbd.gfs1 && block == sbd.sd_meta_dir.no_addr)
print_gfs2("-------------- Master directory -----------------");
else if (!sbd.gfs1 && block == RGLIST_DUMMY_BLOCK)
print_gfs2("------------------ RG List ----------------------");
@@ -449,11 +449,11 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
print_gfs2("-------------------- Journal List --------------------");
else {
if (sbd.gfs1) {
- if (block == sbd1->sb_rindex_di.no_addr)
+ if (block == sbd.sd_rindex_di.no_addr)
print_gfs2("---------------- rindex file -------------------");
else if (block == gfs1_quota_di.no_addr)
print_gfs2("---------------- Quota file --------------------");
- else if (block == sbd1->sb_jindex_di.no_addr)
+ else if (block == sbd.sd_jindex_di.no_addr)
print_gfs2("--------------- Journal Index ------------------");
else if (block == gfs1_license_di.no_addr)
print_gfs2("--------------- License file -------------------");
@@ -504,7 +504,7 @@ static int hexdump(uint64_t startaddr, uint64_t len, int trunc_zeros,
int i;
uint64_t l;
const char *lpBuffer = bh->b_data;
- const char *zeros_strt = lpBuffer + sbd.bsize;
+ const char *zeros_strt = lpBuffer + sbd.sd_bsize;
int print_field, cursor_line;
const struct lgfs2_metadata *m = get_block_type(bh->b_data);
uint64_t *ref;
@@ -522,7 +522,7 @@ static int hexdump(uint64_t startaddr, uint64_t len, int trunc_zeros,
print_entry_ndx = 0;
while (((termlines && line < termlines &&
line <= ((screen_chunk_size / 16) + 2)) ||
- (!termlines && l < len)) && l < sbd.bsize) {
+ (!termlines && l < len)) && l < sbd.sd_bsize) {
int ptr_not_null = 0;
if (termlines) {
@@ -715,7 +715,7 @@ static uint64_t find_rgrp_block(struct gfs2_inode *dif, int rg)
foffset = rg * sizeof(struct gfs2_rindex);
if (sbd.gfs1) {
uint64_t sd_jbsize =
- (sbd.bsize - sizeof(struct gfs2_meta_header));
+ (sbd.sd_bsize - sizeof(struct gfs2_meta_header));
gfs1_adj = (foffset / sd_jbsize) *
sizeof(struct gfs2_meta_header);
@@ -753,7 +753,7 @@ static uint64_t get_rg_addr(int rgnum)
struct gfs2_inode *riinode;
if (sbd.gfs1)
- gblock = sbd1->sb_rindex_di.no_addr;
+ gblock = sbd.sd_rindex_di.no_addr;
else
gblock = masterblock("rindex");
riinode = lgfs2_inode_read(&sbd, gblock);
@@ -827,7 +827,7 @@ int has_indirect_blocks(void)
int block_is_rindex(uint64_t blk)
{
- if ((sbd.gfs1 && blk == sbd1->sb_rindex_di.no_addr) ||
+ if ((sbd.gfs1 && blk == sbd.sd_rindex_di.no_addr) ||
(blk == masterblock("rindex")))
return TRUE;
return FALSE;
@@ -835,7 +835,7 @@ int block_is_rindex(uint64_t blk)
int block_is_jindex(uint64_t blk)
{
- if ((sbd.gfs1 && blk == sbd1->sb_jindex_di.no_addr))
+ if ((sbd.gfs1 && blk == sbd.sd_jindex_di.no_addr))
return TRUE;
return FALSE;
}
@@ -891,10 +891,11 @@ static int block_has_extended_info(void)
static void read_superblock(int fd)
{
- sbd1 = (struct gfs_sb *)&sbd.sd_sb;
+ struct gfs2_meta_header *mh;
+
ioctl(fd, BLKFLSBUF, 0);
memset(&sbd, 0, sizeof(struct gfs2_sbd));
- sbd.bsize = GFS2_DEFAULT_BSIZE;
+ sbd.sd_bsize = GFS2_DEFAULT_BSIZE;
sbd.device_fd = fd;
bh = bread(&sbd, 0x10);
sbd.jsize = GFS2_DEFAULT_JSIZE;
@@ -902,26 +903,19 @@ static void read_superblock(int fd)
sbd.qcsize = GFS2_DEFAULT_QCSIZE;
sbd.time = time(NULL);
sbd.rgtree.osi_node = NULL;
- gfs2_sb_in(&sbd.sd_sb, bh->b_data);
+ lgfs2_sb_in(&sbd, bh->b_data);
/* Check to see if this is really gfs1 */
- if (sbd1->sb_fs_format == GFS_FORMAT_FS &&
- sbd1->sb_header.mh_type == GFS_METATYPE_SB &&
- sbd1->sb_header.mh_format == GFS_FORMAT_SB &&
- sbd1->sb_multihost_format == GFS_FORMAT_MULTI) {
- struct gfs_sb *sbbuf = (struct gfs_sb *)bh->b_data;
-
+ mh = (struct gfs2_meta_header *)bh->b_data;
+ if (sbd.sd_fs_format == GFS_FORMAT_FS &&
+ be32_to_cpu(mh->mh_type) == GFS_METATYPE_SB &&
+ be32_to_cpu(mh->mh_format) == GFS_FORMAT_SB &&
+ sbd.sd_multihost_format == GFS_FORMAT_MULTI) {
sbd.gfs1 = TRUE;
- sbd1->sb_flags = be32_to_cpu(sbbuf->sb_flags);
- sbd1->sb_seg_size = be32_to_cpu(sbbuf->sb_seg_size);
- gfs2_inum_in(&sbd1->sb_rindex_di, (void *)&sbbuf->sb_rindex_di);
- gfs2_inum_in(&gfs1_quota_di, (void *)&sbbuf->sb_quota_di);
- gfs2_inum_in(&gfs1_license_di, (void *)&sbbuf->sb_license_di);
}
else
sbd.gfs1 = FALSE;
- sbd.bsize = sbd.sd_sb.sb_bsize;
- if (!sbd.bsize)
- sbd.bsize = GFS2_DEFAULT_BSIZE;
+ if (!sbd.sd_bsize)
+ sbd.sd_bsize = GFS2_DEFAULT_BSIZE;
if (lgfs2_get_dev_info(fd, &sbd.dinfo)) {
perror(device);
exit(-1);
@@ -930,26 +924,25 @@ static void read_superblock(int fd)
fprintf(stderr, "Failed to compute constants.\n");
exit(-1);
}
- if (sbd.gfs1 || (sbd.sd_sb.sb_header.mh_magic == GFS2_MAGIC &&
- sbd.sd_sb.sb_header.mh_type == GFS2_METATYPE_SB))
- block = 0x10 * (GFS2_DEFAULT_BSIZE / sbd.bsize);
+ if (sbd.gfs1 || (be32_to_cpu(mh->mh_magic) == GFS2_MAGIC &&
+ be32_to_cpu(mh->mh_type) == GFS2_METATYPE_SB))
+ block = 0x10 * (GFS2_DEFAULT_BSIZE / sbd.sd_bsize);
else {
block = starting_blk = 0;
}
fix_device_geometry(&sbd);
if(sbd.gfs1) {
- sbd.sd_inptrs = (sbd.bsize - sizeof(struct gfs_indirect)) /
+ sbd.sd_inptrs = (sbd.sd_bsize - sizeof(struct gfs_indirect)) /
sizeof(uint64_t);
- sbd.sd_diptrs = (sbd.bsize - sizeof(struct gfs_dinode)) /
+ sbd.sd_diptrs = (sbd.sd_bsize - sizeof(struct gfs_dinode)) /
sizeof(uint64_t);
- sbd.md.riinode = lgfs2_inode_read(&sbd, sbd1->sb_rindex_di.no_addr);
+ sbd.md.riinode = lgfs2_inode_read(&sbd, sbd.sd_rindex_di.no_addr);
} else {
- sbd.sd_inptrs = (sbd.bsize - sizeof(struct gfs2_meta_header)) /
+ sbd.sd_inptrs = (sbd.sd_bsize - sizeof(struct gfs2_meta_header)) /
sizeof(uint64_t);
- sbd.sd_diptrs = (sbd.bsize - sizeof(struct gfs2_dinode)) /
+ sbd.sd_diptrs = (sbd.sd_bsize - sizeof(struct gfs2_dinode)) /
sizeof(uint64_t);
- sbd.master_dir = lgfs2_inode_read(&sbd,
- sbd.sd_sb.sb_master_dir.no_addr);
+ sbd.master_dir = lgfs2_inode_read(&sbd, sbd.sd_meta_dir.no_addr);
if (sbd.master_dir == NULL) {
sbd.md.riinode = NULL;
} else {
@@ -980,7 +973,7 @@ static int read_master_dir(void)
{
ioctl(sbd.device_fd, BLKFLSBUF, 0);
- bh = bread(&sbd, sbd.sd_sb.sb_master_dir.no_addr);
+ bh = bread(&sbd, sbd.sd_meta_dir.no_addr);
if (bh == NULL)
return 1;
di = (struct gfs2_dinode *)bh->b_data;
@@ -996,12 +989,12 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
if (block == RGLIST_DUMMY_BLOCK) {
if (sbd.gfs1)
- blk = sbd1->sb_rindex_di.no_addr;
+ blk = sbd.sd_rindex_di.no_addr;
else
blk = masterblock("rindex");
} else if (block == JOURNALS_DUMMY_BLOCK) {
if (sbd.gfs1)
- blk = sbd1->sb_jindex_di.no_addr;
+ blk = sbd.sd_jindex_di.no_addr;
else
blk = masterblock("jindex");
} else
@@ -1013,7 +1006,7 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
if (bh == NULL || bh->b_blocknr != blk) { /* If we changed blocks from the last read */
if (bh != NULL)
brelse(bh);
- dev_offset = blk * sbd.bsize;
+ dev_offset = blk * sbd.sd_bsize;
ioctl(sbd.device_fd, BLKFLSBUF, 0);
if (!(bh = bread(&sbd, blk))) {
fprintf(stderr, "read error: %s from %s:%d: "
@@ -1030,27 +1023,27 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
return 0;
indirect_blocks = 0;
lines_per_row[dmode] = 1;
- if (gfs2_struct_type == GFS2_METATYPE_SB || blk == 0x10 * (4096 / sbd.bsize)) {
- gfs2_sb_in(&sbd.sd_sb, bh->b_data);
+ if (gfs2_struct_type == GFS2_METATYPE_SB || blk == 0x10 * (4096 / sbd.sd_bsize)) {
+ lgfs2_sb_in(&sbd, bh->b_data);
memset(indirect, 0, sizeof(struct iinfo));
- indirect->ii[0].block = sbd.sd_sb.sb_master_dir.no_addr;
+ indirect->ii[0].block = sbd.sd_meta_dir.no_addr;
indirect->ii[0].is_dir = TRUE;
indirect->ii[0].dirents = 2;
memcpy(&indirect->ii[0].dirent[0].filename, "root", 4);
indirect->ii[0].dirent[0].dirent.de_inum.no_formal_ino =
- sbd.sd_sb.sb_root_dir.no_formal_ino;
+ sbd.sd_root_dir.no_formal_ino;
indirect->ii[0].dirent[0].dirent.de_inum.no_addr =
- sbd.sd_sb.sb_root_dir.no_addr;
- indirect->ii[0].dirent[0].block = sbd.sd_sb.sb_root_dir.no_addr;
+ sbd.sd_root_dir.no_addr;
+ indirect->ii[0].dirent[0].block = sbd.sd_root_dir.no_addr;
indirect->ii[0].dirent[0].dirent.de_type = DT_DIR;
memcpy(&indirect->ii[0].dirent[1].filename, "master", 7);
indirect->ii[0].dirent[1].dirent.de_inum.no_formal_ino =
- sbd.sd_sb.sb_master_dir.no_formal_ino;
+ sbd.sd_meta_dir.no_formal_ino;
indirect->ii[0].dirent[1].dirent.de_inum.no_addr =
- sbd.sd_sb.sb_master_dir.no_addr;
- indirect->ii[0].dirent[1].block = sbd.sd_sb.sb_master_dir.no_addr;
+ sbd.sd_meta_dir.no_addr;
+ indirect->ii[0].dirent[1].block = sbd.sd_meta_dir.no_addr;
indirect->ii[0].dirent[1].dirent.de_type = DT_DIR;
}
else if (gfs2_struct_type == GFS2_METATYPE_DI) {
@@ -1085,7 +1078,7 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
move(line, 0);
}
if (dmode == HEX_MODE) { /* if hex display mode */
- uint64_t len = sbd.bsize;
+ uint64_t len = sbd.sd_bsize;
if (gfs2_struct_type == GFS2_METATYPE_DI)
len = struct_len + be64_to_cpu(di->di_size);
@@ -1164,7 +1157,7 @@ static uint64_t find_metablockoftype_slow(uint64_t startblk, int metatype, int p
int found = 0;
struct gfs2_buffer_head *lbh;
- last_fs_block = lseek(sbd.device_fd, 0, SEEK_END) / sbd.bsize;
+ last_fs_block = lseek(sbd.device_fd, 0, SEEK_END) / sbd.sd_bsize;
for (blk = startblk + 1; blk < last_fs_block; blk++) {
lbh = bread(&sbd, blk);
/* Can't use get_block_type here (returns false "none") */
@@ -1197,7 +1190,7 @@ static int find_rg_metatype(struct rgrp_tree *rgd, uint64_t *blk, uint64_t start
int found;
unsigned i, j, m;
struct gfs2_buffer_head *bhp = NULL;
- uint64_t *ibuf = malloc(sbd.bsize * GFS2_NBBY * sizeof(uint64_t));
+ uint64_t *ibuf = malloc(sbd.sd_bsize * GFS2_NBBY * sizeof(uint64_t));
for (i = 0; i < rgd->rt_length; i++) {
m = lgfs2_bm_scan(rgd, i, ibuf, GFS2_BLKST_DINODE);
@@ -1322,21 +1315,21 @@ uint64_t check_keywords(const char *kword)
unsigned long long blk = 0;
if (!strcmp(kword, "sb") ||!strcmp(kword, "superblock"))
- blk = 0x10 * (4096 / sbd.bsize); /* superblock */
+ blk = 0x10 * (4096 / sbd.sd_bsize); /* superblock */
else if (!strcmp(kword, "root") || !strcmp(kword, "rootdir"))
- blk = sbd.sd_sb.sb_root_dir.no_addr;
+ blk = sbd.sd_root_dir.no_addr;
else if (!strcmp(kword, "master")) {
if (sbd.gfs1)
fprintf(stderr, "This is GFS1; there's no master directory.\n");
- else if (!sbd.sd_sb.sb_master_dir.no_addr) {
+ else if (!sbd.sd_meta_dir.no_addr) {
fprintf(stderr, "GFS2 master directory not found on %s\n", device);
exit(-1);
} else
- blk = sbd.sd_sb.sb_master_dir.no_addr;
+ blk = sbd.sd_meta_dir.no_addr;
}
else if (!strcmp(kword, "jindex")) {
if (sbd.gfs1)
- blk = sbd1->sb_jindex_di.no_addr;
+ blk = sbd.sd_jindex_di.no_addr;
else
blk = masterblock("jindex"); /* journal index */
}
@@ -1352,7 +1345,7 @@ uint64_t check_keywords(const char *kword)
}
else if (!strcmp(kword, "rindex") || !strcmp(kword, "rgindex")) {
if (sbd.gfs1)
- blk = sbd1->sb_rindex_di.no_addr;
+ blk = sbd.sd_rindex_di.no_addr;
else
blk = masterblock("rindex");
} else if (!strcmp(kword, "rgs")) {
@@ -1448,7 +1441,7 @@ static void hex_edit(int *exitch)
int left_off;
int ch;
- left_off = ((block * sbd.bsize) < 0xffffffff) ? 9 : 17;
+ left_off = ((block * sbd.sd_bsize) < 0xffffffff) ? 9 : 17;
/* 8 and 16 char addresses on screen */
if (bobgets(estring, edit_row[HEX_MODE] + 3,
@@ -1480,8 +1473,8 @@ static void hex_edit(int *exitch)
ch += (estring[i+1] - 'A' + 0x0a);
bh->b_data[offset + hexoffset] = ch;
}
- if (pwrite(sbd.device_fd, bh->b_data, sbd.bsize, dev_offset) !=
- sbd.bsize) {
+ if (pwrite(sbd.device_fd, bh->b_data, sbd.sd_bsize, dev_offset) !=
+ sbd.sd_bsize) {
fprintf(stderr, "write error: %s from %s:%d: "
"offset %lld (0x%llx)\n",
strerror(errno),
@@ -1515,10 +1508,10 @@ static void pageup(void)
if (dmode == GFS2_MODE || offset==0) {
block--;
if (dmode == HEX_MODE)
- offset = (sbd.bsize % screen_chunk_size) > 0 ?
+ offset = (sbd.sd_bsize % screen_chunk_size) > 0 ?
screen_chunk_size *
- (sbd.bsize / screen_chunk_size) :
- sbd.bsize - screen_chunk_size;
+ (sbd.sd_bsize / screen_chunk_size) :
+ sbd.sd_bsize - screen_chunk_size;
else
offset = 0;
} else
@@ -1546,7 +1539,7 @@ static void pagedn(void)
else {
start_row[dmode] = edit_row[dmode] = 0;
if (dmode == GFS2_MODE ||
- offset + screen_chunk_size >= sbd.bsize) {
+ offset + screen_chunk_size >= sbd.sd_bsize) {
block++;
offset = 0;
} else
@@ -1844,7 +1837,7 @@ static void interactive_mode(void)
edit_row[dmode] = 0;
}
else {
- block = 0x10 * (4096 / sbd.bsize);
+ block = 0x10 * (4096 / sbd.sd_bsize);
push_block(block);
offset = 0;
}
@@ -2210,7 +2203,7 @@ static int count_dinode_bits(struct gfs2_buffer_head *rbh)
else
blk = sizeof(struct gfs2_meta_header);
- for (; blk < sbd.bsize; blk++) {
+ for (; blk < sbd.sd_bsize; blk++) {
byte = rbh->b_data + (blk / GFS2_NBBY);
bit = (blk % GFS2_NBBY) * GFS2_BIT_SIZE;
if (((*byte >> bit) & GFS2_BIT_MASK) == GFS2_BLKST_DINODE)
@@ -2255,7 +2248,7 @@ static void rg_repair(void)
if (gfs2_check_meta(rbh->b_data, mtype)) { /* wrong type */
printf("Damaged. Repairing...");
/* Fix the meta header */
- memset(rbh->b_data, 0, sbd.bsize);
+ memset(rbh->b_data, 0, sbd.sd_bsize);
mh = (struct gfs2_meta_header *)rbh->b_data;
mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
mh->mh_type = cpu_to_be32(mtype);
@@ -2558,7 +2551,7 @@ int main(int argc, char *argv[])
memset(edit_size, 0, sizeof(edit_size));
memset(last_entry_onscreen, 0, sizeof(last_entry_onscreen));
dmode = INIT_MODE;
- sbd.bsize = 4096;
+ sbd.sd_bsize = 4096;
block = starting_blk = 0x10;
for (i = 0; i < BLOCK_STACK_SIZE; i++) {
blockstack[i].dmode = HEX_MODE;
@@ -2582,12 +2575,12 @@ int main(int argc, char *argv[])
fd = open(device, O_RDWR);
if (fd < 0)
die("can't open %s: %s\n", device, strerror(errno));
- max_block = lseek(fd, 0, SEEK_END) / sbd.bsize;
+ max_block = lseek(fd, 0, SEEK_END) / sbd.sd_bsize;
read_superblock(fd);
if (read_rindex())
exit(-1);
- max_block = lseek(fd, 0, SEEK_END) / sbd.bsize;
+ max_block = lseek(fd, 0, SEEK_END) / sbd.sd_bsize;
if (sbd.gfs1)
edit_row[GFS2_MODE]++;
else if (read_master_dir() != 0)
@@ -2595,7 +2588,7 @@ int main(int argc, char *argv[])
process_parameters(argc, argv, 1); /* get what to print from cmdline */
- block = blockstack[0].block = starting_blk * (4096 / sbd.bsize);
+ block = blockstack[0].block = starting_blk * (4096 / sbd.sd_bsize);
if (termlines)
interactive_mode();
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index b0ca1fba..fb060089 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -46,7 +46,6 @@ extern int start_row[DMODES], end_row[DMODES], lines_per_row[DMODES];
extern int edit_size[DMODES], last_entry_onscreen[DMODES];
extern char edit_fmt[80];
extern struct gfs2_sbd sbd;
-extern struct gfs_sb *sbd1;
extern struct gfs2_inum gfs1_quota_di; /* kludge because gfs2 sb too small */
extern struct gfs2_inum gfs1_license_di; /* kludge because gfs2 sb too small */
extern struct gfs2_dinode *di;
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index 0da00235..eb8fb4f6 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -38,7 +38,7 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size)
uint64_t jindex_block, jblock = 0;
int amtread;
struct gfs2_buffer_head *jindex_bh, *j_bh;
- char jbuf[sbd.bsize];
+ char jbuf[sbd.sd_bsize];
journal_num = atoi(journal + 7);
if (journal_num < 0)
@@ -46,7 +46,7 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size)
/* Figure out the block of the jindex file */
if (sbd.gfs1)
- jindex_block = sbd1->sb_jindex_di.no_addr;
+ jindex_block = sbd.sd_jindex_di.no_addr;
else
jindex_block = masterblock("jindex");
/* read in the block */
@@ -134,8 +134,8 @@ static int fsck_readi(struct gfs2_inode *ip, void *rbuf, uint64_t roffset,
o = roffset % sdp->sd_jbsize;
lblock = roffset / sdp->sd_jbsize;
} else {
- lblock = roffset >> sdp->sd_sb.sb_bsize_shift;
- o = roffset & (sdp->bsize - 1);
+ lblock = roffset >> sdp->sd_bsize_shift;
+ o = roffset & (sdp->sd_bsize - 1);
}
if (!ip->i_height) /* inode_is_stuffed */
@@ -145,8 +145,8 @@ static int fsck_readi(struct gfs2_inode *ip, void *rbuf, uint64_t roffset,
while (copied < size) {
amount = size - copied;
- if (amount > sdp->bsize - o)
- amount = sdp->bsize - o;
+ if (amount > sdp->sd_bsize - o)
+ amount = sdp->sd_bsize - o;
if (!extlen)
block_map(ip, lblock, ¬_new, &dblock, &extlen,
FALSE);
@@ -331,7 +331,7 @@ static uint64_t find_wrap_pt(struct gfs2_inode *ji, char *jbuf, uint64_t jblock,
uint64_t jb = 0;
uint64_t highest_seq = 0;
- for (jb = 0; jb < j_size; jb += (sbd.gfs1 ? 1 : sbd.bsize)) {
+ for (jb = 0; jb < j_size; jb += (sbd.gfs1 ? 1 : sbd.sd_bsize)) {
int found = 0;
if (sbd.gfs1) {
@@ -344,7 +344,7 @@ static uint64_t find_wrap_pt(struct gfs2_inode *ji, char *jbuf, uint64_t jblock,
int copied;
uint64_t abs_block;
- copied = fsck_readi(ji, jbuf, jb, sbd.bsize, &abs_block);
+ copied = fsck_readi(ji, jbuf, jb, sbd.sd_bsize, &abs_block);
if (!copied) /* end of file */
break;
found = is_wrap_pt(jbuf, &highest_seq);
@@ -385,11 +385,11 @@ static int process_ld(uint64_t abs_block, uint64_t wrappt, uint64_t j_size,
b = (uint64_t *)(buf + sizeof(struct gfs_log_descriptor));
else
b = (uint64_t *)(buf + sizeof(struct gfs2_log_descriptor));
- *prnt = ld_is_pertinent(b, (buf + sbd.bsize), tblk, rgd, bitblk);
+ *prnt = ld_is_pertinent(b, (buf + sbd.sd_bsize), tblk, rgd, bitblk);
if (*prnt) {
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log descriptor, ",
- abs_block, ((jb + wrappt) % j_size) / sbd.bsize);
+ abs_block, ((jb + wrappt) % j_size) / sbd.sd_bsize);
print_gfs2("type %"PRIu32" ", ld_type);
for (ltndx = 0;; ltndx++) {
@@ -406,7 +406,7 @@ static int process_ld(uint64_t abs_block, uint64_t wrappt, uint64_t j_size,
if (ld_type == GFS2_LOG_DESC_METADATA ||
ld_type == GFS_LOG_DESC_METADATA)
is_meta_ld = 1;
- ld_blocks -= print_ld_blks(b, (buf + sbd.bsize), line, tblk, tblk_off,
+ ld_blocks -= print_ld_blks(b, (buf + sbd.sd_bsize), line, tblk, tblk_off,
bitblk, rgd, abs_block, *prnt, bblk_off,
is_meta_ld);
@@ -435,7 +435,7 @@ static int meta_has_ref(uint64_t abs_block, int tblk)
}
}
b = (uint64_t *)(mbh->b_data + structlen);
- while (!has_ref && mtype && (char *)b < mbh->b_data + sbd.bsize) {
+ while (!has_ref && mtype && (char *)b < mbh->b_data + sbd.sd_bsize) {
if (be64_to_cpu(*b) == tblk)
has_ref = 1;
b++;
@@ -492,7 +492,7 @@ static void display_log_header(void *buf, uint64_t *highest_seq, uint64_t abs_bl
} else {
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: Seq: 0x%"PRIx64", "
"tail: 0x%"PRIx32", blk: 0x%"PRIx32" [%s]",
- abs_block, (jb % j_size) / sbd.bsize, be64_to_cpu(lh->lh_sequence),
+ abs_block, (jb % j_size) / sbd.sd_bsize, be64_to_cpu(lh->lh_sequence),
be32_to_cpu(lh->lh_tail), be32_to_cpu(lh->lh_blkno), flags_str);
}
}
@@ -544,7 +544,7 @@ void dump_journal(const char *journal, int tblk)
fprintf(stderr, "Out of memory\n");
exit(-1);
}
- jbuf = malloc(sbd.bsize);
+ jbuf = malloc(sbd.sd_bsize);
if (jbuf == NULL) {
fprintf(stderr, "Out of memory\n");
exit(-1);
@@ -578,7 +578,7 @@ void dump_journal(const char *journal, int tblk)
}
wrappt = find_wrap_pt(j_inode, jbuf, jblock, j_size);
- wp = wrappt / (sbd.gfs1 ? 1 : sbd.bsize);
+ wp = wrappt / (sbd.gfs1 ? 1 : sbd.sd_bsize);
print_gfs2("Starting at journal wrap block: 0x%llx "
"(j + 0x%llx)",
(unsigned long long)jblock + wp,
@@ -586,7 +586,7 @@ void dump_journal(const char *journal, int tblk)
eol(0);
}
- for (jb = 0; jb < j_size; jb += (sbd.gfs1 ? 1 : sbd.bsize)) {
+ for (jb = 0; jb < j_size; jb += (sbd.gfs1 ? 1 : sbd.sd_bsize)) {
int is_pertinent = 1;
uint32_t block_type = 0;
@@ -599,7 +599,7 @@ void dump_journal(const char *journal, int tblk)
} else {
int error = fsck_readi(j_inode, (void *)jbuf,
((jb + wrappt) % j_size),
- sbd.bsize, &abs_block);
+ sbd.sd_bsize, &abs_block);
if (!error) /* end of file */
break;
buf = jbuf;
@@ -625,10 +625,10 @@ void dump_journal(const char *journal, int tblk)
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log descriptor"
" continuation block", abs_block,
- ((jb + wrappt) % j_size) / sbd.bsize);
+ ((jb + wrappt) % j_size) / sbd.sd_bsize);
eol(0);
print_gfs2(" ");
- ld_blocks -= print_ld_blks(b, (buf + sbd.bsize), start_line,
+ ld_blocks -= print_ld_blks(b, (buf + sbd.sd_bsize), start_line,
tblk, &tblk_off, 0, rgd, 0, 1, NULL, 0);
} else if (block_type == 0) {
continue;
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index e55b66f6..b4706248 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -311,7 +311,7 @@ static size_t di_save_len(const char *buf, uint64_t owner)
indirect pointers, dirents, symlinks or fs internal data */
if (di_height > 0 || S_ISDIR(di_mode) || S_ISLNK(di_mode) || gfs1dir
|| block_is_systemfile(owner))
- return sbd.bsize;
+ return sbd.sd_bsize;
return sizeof(struct gfs2_dinode);
}
@@ -335,7 +335,7 @@ static int get_gfs_struct_info(const char *buf, uint64_t owner, unsigned *block_
*block_type = 0;
if (gstruct_len != NULL)
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
gfs2_meta_header_in(&mh, buf);
if (mh.mh_magic != GFS2_MAGIC)
@@ -355,22 +355,22 @@ static int get_gfs_struct_info(const char *buf, uint64_t owner, unsigned *block_
*gstruct_len = sizeof(struct gfs2_sb);
break;
case GFS2_METATYPE_RG: /* 2 (rsrc grp hdr) */
- *gstruct_len = sbd.bsize; /*sizeof(struct gfs_rgrp);*/
+ *gstruct_len = sbd.sd_bsize; /*sizeof(struct gfs_rgrp);*/
break;
case GFS2_METATYPE_RB: /* 3 (rsrc grp bitblk) */
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
case GFS2_METATYPE_DI: /* 4 (disk inode) */
*gstruct_len = di_save_len(buf, owner);
break;
case GFS2_METATYPE_IN: /* 5 (indir inode blklst) */
- *gstruct_len = sbd.bsize; /*sizeof(struct gfs_indirect);*/
+ *gstruct_len = sbd.sd_bsize; /*sizeof(struct gfs_indirect);*/
break;
case GFS2_METATYPE_LF: /* 6 (leaf dinode blklst) */
- *gstruct_len = sbd.bsize; /*sizeof(struct gfs_leaf);*/
+ *gstruct_len = sbd.sd_bsize; /*sizeof(struct gfs_leaf);*/
break;
case GFS2_METATYPE_JD: /* 7 (journal data) */
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
case GFS2_METATYPE_LH: /* 8 (log header) */
if (sbd.gfs1)
@@ -382,16 +382,16 @@ static int get_gfs_struct_info(const char *buf, uint64_t owner, unsigned *block_
*gstruct_len = sizeof(struct gfs2_log_header);
break;
case GFS2_METATYPE_LD: /* 9 (log descriptor) */
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
case GFS2_METATYPE_EA: /* 10 (extended attr hdr) */
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
case GFS2_METATYPE_ED: /* 11 (extended attr data) */
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
default:
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
}
return 0;
@@ -571,12 +571,12 @@ struct block_range {
static int block_range_prepare(struct block_range *br)
{
- br->buf = calloc(br->len, sbd.bsize + sizeof(*br->blktype) + sizeof(*br->blklen));
+ br->buf = calloc(br->len, sbd.sd_bsize + sizeof(*br->blktype) + sizeof(*br->blklen));
if (br->buf == NULL) {
perror("Failed to allocate block range buffer");
return 1;
}
- br->blktype = (unsigned *)(br->buf + (br->len * sbd.bsize));
+ br->blktype = (unsigned *)(br->buf + (br->len * sbd.sd_bsize));
br->blklen = br->blktype + br->len;
return 0;
}
@@ -596,7 +596,7 @@ static int block_range_check(struct block_range *br)
static void block_range_setinfo(struct block_range *br, uint64_t owner)
{
for (unsigned i = 0; i < br->len; i++) {
- char *buf = br->buf + (i * sbd.bsize);
+ char *buf = br->buf + (i * sbd.sd_bsize);
uint64_t addr = br->start + i;
uint64_t _owner = (owner == 0) ? addr : owner;
@@ -644,7 +644,7 @@ static int save_range(struct metafd *mfd, struct block_range *br)
for (unsigned i = 0; i < br->len; i++) {
int err;
- err = save_buf(mfd, br->buf + (i * sbd.bsize), br->start + i, br->blklen[i]);
+ err = save_buf(mfd, br->buf + (i * sbd.sd_bsize), br->start + i, br->blklen[i]);
if (err != 0)
return err;
}
@@ -661,8 +661,8 @@ static int check_read_range(int fd, struct block_range *br, uint64_t owner)
if (block_range_check(br) != 0)
return 1;
- size = br->len * sbd.bsize;
- if (pread(sbd.device_fd, br->buf, size, sbd.bsize * br->start) != size) {
+ size = br->len * sbd.sd_bsize;
+ if (pread(sbd.device_fd, br->buf, size, sbd.sd_bsize * br->start) != size) {
fprintf(stderr, "Failed to read block range 0x%"PRIx64" (%u blocks): %s\n",
br->start, br->len, strerror(errno));
free(br->buf);
@@ -698,7 +698,7 @@ static void save_ea_block(struct metafd *mfd, char *buf, uint64_t owner)
uint32_t rec_len = 0;
int e;
- for (e = sizeof(struct gfs2_meta_header); e < sbd.bsize; e += rec_len) {
+ for (e = sizeof(struct gfs2_meta_header); e < sbd.sd_bsize; e += rec_len) {
uint64_t blk, *b;
int charoff, i;
@@ -716,7 +716,7 @@ static void save_ea_block(struct metafd *mfd, char *buf, uint64_t owner)
blk = be64_to_cpu(*b);
_buf = check_read_block(sbd.device_fd, blk, owner, NULL, NULL);
if (_buf != NULL) {
- save_buf(mfd, _buf, blk, sbd.bsize);
+ save_buf(mfd, _buf, blk, sbd.sd_bsize);
free(_buf);
}
}
@@ -737,7 +737,7 @@ static void save_indirect_range(struct metafd *mfd, struct block_range **brp, ui
save_range(mfd, br);
for (unsigned i = 0; i < br->len; i++) {
if (br->blktype[i] == GFS2_METATYPE_EA)
- save_ea_block(mfd, br->buf + (i * sbd.bsize), owner);
+ save_ea_block(mfd, br->buf + (i * sbd.sd_bsize), owner);
}
if (q) {
block_range_queue_insert(q, br);
@@ -756,7 +756,7 @@ static void save_indirect_blocks(struct metafd *mfd, char *buf, uint64_t owner,
uint64_t *ptr;
for (ptr = (uint64_t *)(buf + headsize);
- (char *)ptr < (buf + sbd.bsize); ptr++) {
+ (char *)ptr < (buf + sbd.sd_bsize); ptr++) {
if (!*ptr)
continue;
@@ -802,8 +802,8 @@ static int save_leaf_chain(struct metafd *mfd, struct gfs2_sbd *sdp, char *buf)
if (gfs2_check_range(sdp, blk) != 0)
return 0;
- r = pread(sdp->device_fd, buf, sdp->bsize, sdp->bsize * blk);
- if (r != sdp->bsize) {
+ r = pread(sdp->device_fd, buf, sdp->sd_bsize, sdp->sd_bsize * blk);
+ if (r != sdp->sd_bsize) {
fprintf(stderr, "Failed to read leaf block %"PRIx64": %s\n",
blk, strerror(errno));
free(buf);
@@ -811,7 +811,7 @@ static int save_leaf_chain(struct metafd *mfd, struct gfs2_sbd *sdp, char *buf)
}
report_progress(blk, 0);
if (gfs2_check_meta(buf, GFS2_METATYPE_LF) == 0) {
- int ret = save_buf(mfd, buf, blk, sdp->bsize);
+ int ret = save_buf(mfd, buf, blk, sdp->sd_bsize);
if (ret != 0) {
free(buf);
return ret;
@@ -828,7 +828,7 @@ static void save_leaf_blocks(struct metafd *mfd, struct block_range_queue *q)
struct block_range *br = q->tail;
for (unsigned i = 0; i < br->len; i++) {
- char *buf = br->buf + (i * sbd.bsize);
+ char *buf = br->buf + (i * sbd.sd_bsize);
save_leaf_chain(mfd, &sbd, buf);
}
@@ -896,7 +896,7 @@ static void save_inode_data(struct metafd *mfd, char *ibuf, uint64_t iblk)
struct block_range *q = block_range_queue_pop(&indq[i - 1]);
for (unsigned j = 0; j < q->len; j++) {
- char *_buf = q->buf + (j * sbd.bsize);
+ char *_buf = q->buf + (j * sbd.sd_bsize);
save_indirect_blocks(mfd, _buf, iblk, nextq, sizeof(dip->di_header));
}
@@ -949,8 +949,7 @@ static void get_journal_inode_blocks(void)
struct gfs_jindex ji;
char jbuf[sizeof(struct gfs_jindex)];
- j_inode = lgfs2_gfs_inode_read(&sbd,
- sbd1->sb_jindex_di.no_addr);
+ j_inode = lgfs2_gfs_inode_read(&sbd, sbd.sd_jindex_di.no_addr);
if (j_inode == NULL) {
fprintf(stderr, "Error reading journal inode: %s\n", strerror(errno));
return;
@@ -980,7 +979,7 @@ static void save_allocated_range(struct metafd *mfd, struct block_range *br)
save_range(mfd, br);
for (unsigned i = 0; i < br->len; i++) {
- char *buf = br->buf + (i * sbd.bsize);
+ char *buf = br->buf + (i * sbd.sd_bsize);
if (br->blktype[i] == GFS2_METATYPE_DI)
save_inode_data(mfd, buf, br->start + i);
@@ -992,7 +991,7 @@ static void save_allocated(struct rgrp_tree *rgd, struct metafd *mfd)
{
uint64_t blk = 0;
unsigned i, j, m;
- uint64_t *ibuf = malloc(sbd.bsize * GFS2_NBBY * sizeof(uint64_t));
+ uint64_t *ibuf = malloc(sbd.sd_bsize * GFS2_NBBY * sizeof(uint64_t));
for (i = 0; i < rgd->rt_length; i++) {
struct block_range br = {0};
@@ -1036,8 +1035,8 @@ static void save_allocated(struct rgrp_tree *rgd, struct metafd *mfd)
static char *rgrp_read(struct gfs2_sbd *sdp, uint64_t addr, unsigned blocks)
{
- size_t len = blocks * sdp->bsize;
- off_t off = addr * sdp->bsize;
+ size_t len = blocks * sdp->sd_bsize;
+ off_t off = addr * sdp->sd_bsize;
char *buf;
if (blocks == 0 || gfs2_check_range(sdp, addr))
@@ -1064,13 +1063,13 @@ static void save_rgrp(struct gfs2_sbd *sdp, struct metafd *mfd, struct rgrp_tree
return;
for (unsigned i = 0; i < rgd->rt_length; i++)
- rgd->bits[i].bi_data = buf + (i * sdp->bsize);
+ rgd->bits[i].bi_data = buf + (i * sdp->sd_bsize);
log_debug("RG at %"PRIu64" is %"PRIu32" long\n", addr, rgd->rt_length);
/* Save the rg and bitmaps */
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_buf(mfd, buf + (i * sdp->sd_bsize), rgd->rt_addr + i, sdp->sd_bsize);
}
/* Save the other metadata: inodes, etc. if mode is not 'savergs' */
if (withcontents)
@@ -1130,11 +1129,11 @@ void savemeta(char *out_fn, int saveoption, int gziplevel)
blks_saved = 0;
if (sbd.gfs1)
- sbd.bsize = sbd.sd_sb.sb_bsize;
+ sbd.sd_bsize = sbd.sd_bsize;
printf("There are %llu blocks of %u bytes in the filesystem.\n",
- (unsigned long long)sbd.fssize, sbd.bsize);
+ (unsigned long long)sbd.fssize, sbd.sd_bsize);
- printf("Filesystem size: %.2fGB\n", (sbd.fssize * sbd.bsize) / ((float)(1 << 30)));
+ printf("Filesystem size: %.2fGB\n", (sbd.fssize * sbd.sd_bsize) / ((float)(1 << 30)));
get_journal_inode_blocks();
err = init_per_node_lookup();
@@ -1142,13 +1141,13 @@ void savemeta(char *out_fn, int saveoption, int gziplevel)
exit(1);
/* Write the savemeta file header */
- err = save_header(&mfd, sbd.fssize * sbd.bsize);
+ err = save_header(&mfd, sbd.fssize * sbd.sd_bsize);
if (err) {
perror("Failed to write metadata file header");
exit(1);
}
/* Save off the superblock */
- sb_addr = GFS2_SB_ADDR * GFS2_BASIC_BLOCK / sbd.bsize;
+ sb_addr = GFS2_SB_ADDR * GFS2_BASIC_BLOCK / sbd.sd_bsize;
buf = check_read_block(sbd.device_fd, sb_addr, 0, NULL, NULL);
if (buf != NULL) {
if (sbd.gfs1)
@@ -1163,10 +1162,10 @@ void savemeta(char *out_fn, int saveoption, int gziplevel)
uint64_t blk;
int j;
- blk = sbd1->sb_rindex_di.no_addr;
+ blk = sbd.sd_rindex_di.no_addr;
buf = check_read_block(sbd.device_fd, blk, blk, NULL, NULL);
if (buf != NULL) {
- save_buf(&mfd, buf, blk, sbd.bsize);
+ save_buf(&mfd, buf, blk, sbd.sd_bsize);
save_inode_data(&mfd, buf, blk);
free(buf);
}
@@ -1230,7 +1229,7 @@ static char *restore_block(struct metafd *mfd, struct saved_metablock *svb)
return NULL;
}
- if (svb->siglen > sbd.bsize) {
+ if (svb->siglen > sbd.sd_bsize) {
fprintf(stderr, "Bad record length: %u for block %"PRIu64" (0x%"PRIx64").\n",
svb->siglen, svb->blk, svb->blk);
return NULL;
@@ -1252,17 +1251,16 @@ static int restore_super(struct metafd *mfd, void *buf, int printonly)
{
int ret;
- gfs2_sb_in(&sbd.sd_sb, buf);
- sbd1 = (struct gfs_sb *)&sbd.sd_sb;
- ret = check_sb(&sbd.sd_sb);
+ lgfs2_sb_in(&sbd, buf);
+ ret = check_sb(buf);
if (ret < 0) {
fprintf(stderr, "Error: Invalid superblock in metadata file.\n");
return -1;
}
if (ret == 1)
sbd.gfs1 = 1;
- sbd.bsize = sbd.sd_sb.sb_bsize;
- if ((!printonly) && lgfs2_sb_write(&sbd.sd_sb, sbd.device_fd, sbd.bsize)) {
+ sbd.sd_bsize = sbd.sd_bsize;
+ if ((!printonly) && lgfs2_sb_write(&sbd, sbd.device_fd)) {
fprintf(stderr, "Failed to write superblock\n");
return -1;
}
@@ -1276,7 +1274,7 @@ static int restore_data(int fd, struct metafd *mfd, int printonly)
uint64_t writes = 0;
char *buf;
- buf = calloc(1, sbd.bsize);
+ buf = calloc(1, sbd.sd_bsize);
if (buf == NULL) {
perror("Failed to restore data");
exit(1);
@@ -1304,8 +1302,8 @@ static int restore_data(int fd, struct metafd *mfd, int printonly)
} else {
report_progress(savedata.blk, 0);
memcpy(buf, bp, savedata.siglen);
- memset(buf + savedata.siglen, 0, sbd.bsize - savedata.siglen);
- if (pwrite(fd, buf, sbd.bsize, savedata.blk * sbd.bsize) != sbd.bsize) {
+ memset(buf + savedata.siglen, 0, sbd.sd_bsize - savedata.siglen);
+ if (pwrite(fd, buf, sbd.sd_bsize, savedata.blk * sbd.sd_bsize) != sbd.sd_bsize) {
fprintf(stderr, "write error: %s from %s:%d: block %lld (0x%llx)\n",
strerror(errno), __FUNCTION__, __LINE__,
(unsigned long long)savedata.blk,
@@ -1388,11 +1386,11 @@ static int restore_init(const char *path, struct metafd *mfd, struct savemeta_he
return ret;
if (smh->sh_fs_bytes > 0) {
- sbd.fssize = smh->sh_fs_bytes / sbd.bsize;
+ sbd.fssize = smh->sh_fs_bytes / sbd.sd_bsize;
printf("Saved file system size is %"PRIu64" blocks, %.2fGB\n",
sbd.fssize, smh->sh_fs_bytes / ((float)(1 << 30)));
}
- printf("Block size is %uB\n", sbd.bsize);
+ printf("Block size is %uB\n", sbd.sd_bsize);
printf("This is gfs%c metadata.\n", sbd.gfs1 ? '1': '2');
if (printonly > 1 && printonly == LGFS2_SB_ADDR(&sbd)) {
display_block_type(bp, LGFS2_SB_ADDR(&sbd), TRUE);
@@ -1433,7 +1431,7 @@ void restoremeta(const char *in_fn, const char *out_device, uint64_t printonly)
exit(error);
if (!printonly) {
- uint64_t space = lseek(sbd.device_fd, 0, SEEK_END) / sbd.bsize;
+ uint64_t space = lseek(sbd.device_fd, 0, SEEK_END) / sbd.sd_bsize;
printf("There are %"PRIu64" free blocks on the destination device.\n", space);
}
diff --git a/gfs2/fsck/afterpass1_common.c b/gfs2/fsck/afterpass1_common.c
index 35029202..301986f0 100644
--- a/gfs2/fsck/afterpass1_common.c
+++ b/gfs2/fsck/afterpass1_common.c
@@ -268,7 +268,7 @@ int delete_eattr_entry(struct gfs2_inode *ip, struct gfs2_buffer_head *leaf_bh,
if (!ea_hdr->ea_num_ptrs)
return 0;
- avail_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
+ avail_size = sdp->sd_bsize - sizeof(struct gfs2_meta_header);
max_ptrs = (be32_to_cpu(ea_hdr->ea_data_len) + avail_size - 1) /
avail_size;
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index 7afec319..e9d3c849 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -107,7 +107,7 @@ static void refresh_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
if (rgd->rt_addr + i != blkno)
continue;
- memcpy(rgd->bits[i].bi_data, bh->b_data, sdp->bsize);
+ memcpy(rgd->bits[i].bi_data, bh->b_data, sdp->sd_bsize);
rgd->bits[i].bi_modified = 1;
if (i == 0) { /* this is the rgrp itself */
if (sdp->gfs1)
@@ -158,7 +158,7 @@ static int buf_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
log_err(_("Out of memory when replaying journals.\n"));
return FSCK_ERROR;
}
- memcpy(bh_ip->b_data, bh_log->b_data, sdp->bsize);
+ memcpy(bh_ip->b_data, bh_log->b_data, sdp->sd_bsize);
check_magic = ((struct gfs2_meta_header *)
(bh_ip->b_data))->mh_magic;
@@ -213,7 +213,7 @@ static int revoke_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
if (gfs2_check_meta(bh->b_data, GFS2_METATYPE_LB))
continue;
}
- while (offset + sizeof(uint64_t) <= sdp->sd_sb.sb_bsize) {
+ while (offset + sizeof(uint64_t) <= sdp->sd_bsize) {
blkno = be64_to_cpu(*(__be64 *)(bh->b_data + offset));
log_info( _("Journal replay processing revoke for "
"block #%lld (0x%llx) for journal+0x%x\n"),
@@ -278,7 +278,7 @@ static int databuf_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
log_err(_("Out of memory when replaying journals.\n"));
return FSCK_ERROR;
}
- memcpy(bh_ip->b_data, bh_log->b_data, sdp->bsize);
+ memcpy(bh_ip->b_data, bh_log->b_data, sdp->sd_bsize);
/* Unescape */
if (esc) {
@@ -399,7 +399,7 @@ static int foreach_descriptor(struct gfs2_inode *ip, unsigned int start,
static int check_journal_seq_no(struct gfs2_inode *ip, int fix)
{
int error = 0, wrapped = 0;
- uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_bsize;
uint32_t blk;
struct lgfs2_log_header lh;
uint64_t highest_seq = 0, lowest_seq = 0, prev_seq = 0;
@@ -467,7 +467,7 @@ int preen_is_safe(struct gfs2_sbd *sdp, int preen, int force_check)
return 1; /* not called by rc.sysinit--we're okay to preen */
if (force_check) /* If check was forced by the user? */
return 1; /* user's responsibility--we're okay to preen */
- if (!memcmp(sdp->sd_sb.sb_lockproto + 5, "nolock", 6))
+ if (!memcmp(sdp->sd_lockproto + 5, "nolock", 6))
return 1; /* local file system--preen is okay */
return 0; /* might be mounted on another node--not guaranteed safe */
}
@@ -608,9 +608,9 @@ out:
log_err( _("jid=%u: Failed\n"), j);
reinit:
if (query( _("Do you want to clear the journal instead? (y/n)"))) {
- error = write_journal(sdp->md.journal[j], sdp->bsize,
+ error = write_journal(sdp->md.journal[j], sdp->sd_bsize,
sdp->md.journal[j]->i_size /
- sdp->sd_sb.sb_bsize);
+ sdp->sd_bsize);
log_err(_("jid=%u: journal was cleared.\n"), j);
} else {
log_err( _("jid=%u: journal not cleared.\n"), j);
@@ -873,7 +873,7 @@ int init_jindex(struct gfs2_sbd *sdp, int allow_ji_rebuild)
/* rgrepair requires the journals be read in in order to distinguish
"real" rgrps from rgrps that are just copies left in journals. */
if (sdp->gfs1)
- sdp->md.jiinode = lgfs2_inode_read(sdp, sbd1->sb_jindex_di.no_addr);
+ sdp->md.jiinode = lgfs2_inode_read(sdp, sdp->sd_jindex_di.no_addr);
else
gfs2_lookupi(sdp->master_dir, "jindex", 6, &sdp->md.jiinode);
diff --git a/gfs2/fsck/fsck.h b/gfs2/fsck/fsck.h
index 8b7ac0a9..bc706860 100644
--- a/gfs2/fsck/fsck.h
+++ b/gfs2/fsck/fsck.h
@@ -157,7 +157,6 @@ extern struct osi_root inodetree;
extern int dups_found; /* How many duplicate references have we found? */
extern int dups_found_first; /* How many duplicates have we found the original
reference for? */
-extern struct gfs_sb *sbd1;
static inline int valid_block(struct gfs2_sbd *sdp, uint64_t blkno)
{
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 16cc1b49..35599fb4 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -46,22 +46,22 @@ static int block_mounters(struct gfs2_sbd *sdp, int block_em)
{
if (block_em) {
/* verify it starts with lock_ */
- if (!strncmp(sdp->sd_sb.sb_lockproto, "lock_", 5)) {
+ if (!strncmp(sdp->sd_lockproto, "lock_", 5)) {
/* Change lock_ to fsck_ */
- memcpy(sdp->sd_sb.sb_lockproto, "fsck_", 5);
+ memcpy(sdp->sd_lockproto, "fsck_", 5);
}
/* FIXME: Need to do other verification in the else
* case */
} else {
/* verify it starts with fsck_ */
/* verify it starts with lock_ */
- if (!strncmp(sdp->sd_sb.sb_lockproto, "fsck_", 5)) {
+ if (!strncmp(sdp->sd_lockproto, "fsck_", 5)) {
/* Change fsck_ to lock_ */
- memcpy(sdp->sd_sb.sb_lockproto, "lock_", 5);
+ memcpy(sdp->sd_lockproto, "lock_", 5);
}
}
- if (lgfs2_sb_write(&sdp->sd_sb, sdp->device_fd, sdp->bsize)) {
+ if (lgfs2_sb_write(sdp, sdp->device_fd)) {
stack;
return -1;
}
@@ -134,7 +134,7 @@ static int set_block_ranges(struct gfs2_sbd *sdp)
{
struct osi_node *n, *next = NULL;
struct rgrp_tree *rgd;
- char buf[sdp->sd_sb.sb_bsize];
+ char buf[sdp->sd_bsize];
uint64_t rmax = 0;
uint64_t rmin = 0;
int error;
@@ -163,16 +163,16 @@ static int set_block_ranges(struct gfs2_sbd *sdp)
last_data_block = rmax;
first_data_block = rmin;
- if (fsck_lseek(sdp->device_fd, (last_fs_block * sdp->sd_sb.sb_bsize))){
+ if (fsck_lseek(sdp->device_fd, (last_fs_block * sdp->sd_bsize))){
log_crit( _("Can't seek to last block in file system: %llu"
" (0x%llx)\n"), (unsigned long long)last_fs_block,
(unsigned long long)last_fs_block);
goto fail;
}
- memset(buf, 0, sdp->sd_sb.sb_bsize);
- error = read(sdp->device_fd, buf, sdp->sd_sb.sb_bsize);
- if (error != sdp->sd_sb.sb_bsize){
+ memset(buf, 0, sdp->sd_bsize);
+ error = read(sdp->device_fd, buf, sdp->sd_bsize);
+ if (error != sdp->sd_bsize){
log_crit( _("Can't read last block in file system (error %u), "
"last_fs_block: %llu (0x%llx)\n"), error,
(unsigned long long)last_fs_block,
@@ -212,10 +212,10 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
/* Count up the free blocks in the bitmap */
off = (rgb) ? sizeof(struct gfs2_meta_header) :
sizeof(struct gfs2_rgrp);
- if (total_bytes_to_check <= sdp->bsize - off)
+ if (total_bytes_to_check <= sdp->sd_bsize - off)
bytes_to_check = total_bytes_to_check;
else
- bytes_to_check = sdp->bsize - off;
+ bytes_to_check = sdp->sd_bsize - off;
total_bytes_to_check -= bytes_to_check;
for (x = 0; x < bytes_to_check; x++) {
unsigned char *byte;
@@ -464,7 +464,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
}
log_err(_("Trying to rebuild the master directory.\n"));
inum.no_formal_ino = sdp->md.next_inum++;
- inum.no_addr = sdp->sd_sb.sb_master_dir.no_addr;
+ inum.no_addr = sdp->sd_meta_dir.no_addr;
err = init_dinode(sdp, &bh, &inum, S_IFDIR | 0755, GFS2_DIF_SYSTEM, &inum);
if (err != 0)
return -1;
@@ -651,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->rt_addr * sdp->bsize;
- len = rgd->rt_length * sdp->bsize;
+ start = rgd->rt_addr * sdp->sd_bsize;
+ len = rgd->rt_length * sdp->sd_bsize;
posix_fadvise(sdp->device_fd, start, len, POSIX_FADV_WILLNEED);
}
@@ -800,7 +800,7 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
log_info( _("Initializing special inodes...\n"));
/* Get root dinode */
- sdp->md.rooti = lgfs2_inode_read(sdp, sdp->sd_sb.sb_root_dir.no_addr);
+ sdp->md.rooti = lgfs2_inode_read(sdp, sdp->sd_root_dir.no_addr);
if (sdp->md.rooti == NULL)
return -1;
@@ -845,19 +845,19 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
if (sdp->gfs1) {
/* In gfs1, the license_di is always 3 blocks after the jindex_di */
- if ((sbd1->sb_license_di.no_addr != sbd1->sb_jindex_di.no_addr + 3) ||
- (sbd1->sb_license_di.no_formal_ino != sbd1->sb_jindex_di.no_addr + 3)) {
+ if ((sdp->sd_license_di.no_addr != sdp->sd_jindex_di.no_addr + 3) ||
+ (sdp->sd_license_di.no_formal_ino != sdp->sd_jindex_di.no_addr + 3)) {
if (!query( _("The gfs system statfs inode pointer is incorrect. "
"Okay to correct? (y/n) "))) {
log_err( _("fsck.gfs2 cannot continue without a valid "
"statfs file; aborting.\n"));
goto fail;
}
- sbd1->sb_license_di.no_addr = sbd1->sb_license_di.no_formal_ino
- = sbd1->sb_jindex_di.no_addr + 3;
+ sdp->sd_license_di.no_addr = sdp->sd_license_di.no_formal_ino
+ = sdp->sd_jindex_di.no_addr + 3;
}
- sdp->md.statfs = lgfs2_inode_read(sdp, sbd1->sb_license_di.no_addr);
+ sdp->md.statfs = lgfs2_inode_read(sdp, sdp->sd_license_di.no_addr);
if (sdp->md.statfs == NULL) {
log_crit(_("Error reading statfs inode: %s\n"), strerror(errno));
goto fail;
@@ -902,19 +902,19 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
if (sdp->gfs1) {
/* In gfs1, the quota_di is always 2 blocks after the jindex_di */
- if ((sbd1->sb_quota_di.no_addr != sbd1->sb_jindex_di.no_addr + 2) ||
- (sbd1->sb_quota_di.no_formal_ino != sbd1->sb_jindex_di.no_addr + 2)) {
+ if ((sdp->sd_quota_di.no_addr != sdp->sd_jindex_di.no_addr + 2) ||
+ (sdp->sd_quota_di.no_formal_ino != sdp->sd_jindex_di.no_addr + 2)) {
if (!query( _("The gfs system quota inode pointer is incorrect. "
" Okay to correct? (y/n) "))) {
log_err( _("fsck.gfs2 cannot continue without a valid "
"quota file; aborting.\n"));
goto fail;
}
- sbd1->sb_quota_di.no_addr = sbd1->sb_quota_di.no_formal_ino
- = sbd1->sb_jindex_di.no_addr + 2;
+ sdp->sd_quota_di.no_addr = sdp->sd_quota_di.no_formal_ino
+ = sdp->sd_jindex_di.no_addr + 2;
}
- sdp->md.qinode = lgfs2_inode_read(sdp, sbd1->sb_quota_di.no_addr);
+ sdp->md.qinode = lgfs2_inode_read(sdp, sdp->sd_quota_di.no_addr);
if (sdp->md.qinode == NULL) {
log_crit(_("Error reading quota inode: %s\n"), strerror(errno));
goto fail;
@@ -991,11 +991,11 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
int error;
if (ip->i_formal_ino == 2) {
- if (sdp->sd_sb.sb_master_dir.no_addr)
+ if (sdp->sd_meta_dir.no_addr)
return;
log_warn(_("Found system master directory at: 0x%"PRIx64".\n"),
ip->i_addr);
- sdp->sd_sb.sb_master_dir.no_addr = ip->i_addr;
+ sdp->sd_meta_dir.no_addr = ip->i_addr;
return;
}
if ((!sdp->gfs1 && ip->i_formal_ino == 3) ||
@@ -1015,7 +1015,7 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
goto out_discard_ip;
}
fix_md.jiinode = child_ip;
- sdp->sd_sb.sb_master_dir.no_addr = ip->i_addr;
+ sdp->sd_meta_dir.no_addr = ip->i_addr;
log_warn(_("Found system master directory at: 0x%"PRIx64"\n"),
ip->i_addr);
return;
@@ -1033,8 +1033,7 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
fix_md.pinode = ip;
error = dir_search(ip, "..", 2, NULL, &inum);
if (!error && inum.no_addr) {
- sdp->sd_sb.sb_master_dir.no_addr =
- inum.no_addr;
+ sdp->sd_meta_dir.no_addr = inum.no_addr;
log_warn(_("From per_node's '..' master directory backtracked to: "
"0x%"PRIx64"\n"), inum.no_addr);
}
@@ -1080,7 +1079,7 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
struct gfs2_inum inum;
int error;
- if (sdp->sd_sb.sb_root_dir.no_addr) /* if we know the root dinode */
+ if (sdp->sd_root_dir.no_addr) /* if we know the root dinode */
return; /* we don't need to find the root */
if (!is_dir(ip, sdp->gfs1)) /* if this isn't a directory */
return; /* it can't lead us to the root anyway */
@@ -1091,7 +1090,7 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
if (ip->i_addr == ip->i_bh->b_blocknr) {
log_warn(_("Found the root directory at: 0x%"PRIx64".\n"),
ip->i_addr);
- sdp->sd_sb.sb_root_dir.no_addr = ip->i_addr;
+ sdp->sd_root_dir.no_addr = ip->i_addr;
return;
}
log_warn(_("The root dinode should be at block 0x%"PRIx64" but it "
@@ -1105,7 +1104,7 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
return;
}
root_bh = bread(sdp, ip->i_addr);
- memcpy(root_bh->b_data, ip->i_bh->b_data, sdp->bsize);
+ memcpy(root_bh->b_data, ip->i_bh->b_data, sdp->sd_bsize);
bmodified(root_bh);
brelse(root_bh);
log_warn(_("Root directory copied from the journal.\n"));
@@ -1116,7 +1115,7 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
if (parent_ip && parent_ip->i_addr == ip->i_addr) {
log_warn(_("Found the root directory at: 0x%"PRIx64"\n"),
ip->i_addr);
- sdp->sd_sb.sb_root_dir.no_addr = ip->i_addr;
+ sdp->sd_root_dir.no_addr = ip->i_addr;
inode_put(&parent_ip);
inode_put(&ip);
return;
@@ -1150,7 +1149,7 @@ static int find_rgs_for_bsize(struct gfs2_sbd *sdp, uint64_t startblock,
int found_rg;
struct gfs2_meta_header mh;
- sdp->bsize = GFS2_DEFAULT_BSIZE;
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
max_rg_size = 524288;
/* Max RG size is 2GB. Max block size is 4K. 2G / 4K blks = 524288,
So this is traversing 2GB in 4K block increments. */
@@ -1177,7 +1176,7 @@ static int find_rgs_for_bsize(struct gfs2_sbd *sdp, uint64_t startblock,
rb_addr = (bh->b_blocknr *
(GFS2_DEFAULT_BSIZE / bsize2)) +
(bsize / bsize2) + 1;
- sdp->bsize = bsize2; /* temporarily */
+ sdp->sd_bsize = bsize2; /* temporarily */
rb_bh = bread(sdp, rb_addr);
gfs2_meta_header_in(&mh, rb_bh->b_data);
brelse(rb_bh);
@@ -1193,11 +1192,11 @@ static int find_rgs_for_bsize(struct gfs2_sbd *sdp, uint64_t startblock,
}
brelse(bh);
if (!(*known_bsize)) {
- sdp->bsize = GFS2_DEFAULT_BSIZE;
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
continue;
}
- sdp->bsize = *known_bsize;
+ sdp->sd_bsize = *known_bsize;
log_warn(_("Block size determined to be: %d\n"), *known_bsize);
return 0;
}
@@ -1214,7 +1213,7 @@ static int peruse_metadata(struct gfs2_sbd *sdp, uint64_t startblock)
struct gfs2_buffer_head *bh;
struct gfs2_inode *ip;
- max_rg_size = 2147483648ull / sdp->bsize;
+ max_rg_size = 2147483648ull / sdp->sd_bsize;
/* Max RG size is 2GB. 2G / bsize. */
for (blk = startblock; blk < startblock + max_rg_size; blk++) {
bh = bread(sdp, blk);
@@ -1245,7 +1244,7 @@ static int sb_repair(struct gfs2_sbd *sdp)
memset(&fix_md, 0, sizeof(fix_md));
/* Step 1 - First we need to determine the correct block size. */
- sdp->bsize = GFS2_DEFAULT_BSIZE;
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
log_warn(_("Gathering information to repair the gfs2 superblock. "
"This may take some time.\n"));
error = find_rgs_for_bsize(sdp, (GFS2_SB_ADDR * GFS2_BASIC_BLOCK) /
@@ -1257,7 +1256,7 @@ static int sb_repair(struct gfs2_sbd *sdp)
/* First, figure out the device size. We need that so we can
find a suitable start point to determine what's what. */
half = sdp->dinfo.size / 2; /* in bytes */
- half /= sdp->bsize;
+ half /= sdp->sd_bsize;
/* Start looking halfway through the device for gfs2
structures. If there aren't any at all, forget it. */
error = find_rgs_for_bsize(sdp, half, &known_bsize);
@@ -1274,11 +1273,11 @@ static int sb_repair(struct gfs2_sbd *sdp)
GFS2_DEFAULT_BSIZE);
if (error)
return error;
- if (!sdp->sd_sb.sb_master_dir.no_addr) {
+ if (!sdp->sd_meta_dir.no_addr) {
log_err(_("Unable to locate the system master directory.\n"));
return -1;
}
- if (!sdp->sd_sb.sb_root_dir.no_addr) {
+ if (!sdp->sd_root_dir.no_addr) {
struct gfs2_inum inum;
log_err(_("Unable to locate the root directory.\n"));
@@ -1287,11 +1286,11 @@ static int sb_repair(struct gfs2_sbd *sdp)
creates master immediately after root. */
log_err(_("Can't find any dinodes that might "
"be the root; using master - 1.\n"));
- possible_root = sdp->sd_sb.sb_master_dir.no_addr - 1;
+ possible_root = sdp->sd_meta_dir.no_addr - 1;
}
log_err(_("Found a possible root at: 0x%llx\n"),
(unsigned long long)possible_root);
- sdp->sd_sb.sb_root_dir.no_addr = possible_root;
+ sdp->sd_root_dir.no_addr = possible_root;
sdp->md.rooti = lgfs2_inode_read(sdp, possible_root);
if (!sdp->md.rooti || sdp->md.rooti->i_magic != GFS2_MAGIC) {
struct gfs2_buffer_head *bh = NULL;
@@ -1317,32 +1316,23 @@ static int sb_repair(struct gfs2_sbd *sdp)
}
/* Step 3 - Rebuild the lock protocol and file system table name */
if (query(_("Okay to fix the GFS2 superblock? (y/n)"))) {
- struct gfs2_sb sb;
log_info(_("Found system master directory at: 0x%"PRIx64"\n"),
- sdp->sd_sb.sb_master_dir.no_addr);
- sdp->master_dir = lgfs2_inode_read(sdp,
- sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->sd_meta_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
if (sdp->master_dir == NULL) {
log_crit(_("Error reading master inode: %s\n"), strerror(errno));
return -1;
}
- sdp->master_dir->i_addr = sdp->sd_sb.sb_master_dir.no_addr;
+ sdp->master_dir->i_addr = sdp->sd_meta_dir.no_addr;
log_info(_("Found the root directory at: 0x%"PRIx64"\n"),
- sdp->sd_sb.sb_root_dir.no_addr);
- sdp->md.rooti = lgfs2_inode_read(sdp,
- sdp->sd_sb.sb_root_dir.no_addr);
+ sdp->sd_root_dir.no_addr);
+ sdp->md.rooti = lgfs2_inode_read(sdp, sdp->sd_root_dir.no_addr);
if (sdp->md.rooti == NULL) {
log_crit(_("Error reading root inode: %s\n"), strerror(errno));
return -1;
}
- lgfs2_sb_init(&sb, sdp->bsize, GFS2_FORMAT_FS);
- strcpy(sb.sb_lockproto, GFS2_DEFAULT_LOCKPROTO);
- strcpy(sb.sb_locktable, "unknown");
- sb.sb_master_dir.no_addr = sdp->master_dir->i_addr;
- sb.sb_master_dir.no_formal_ino = sdp->master_dir->i_formal_ino;
- sb.sb_root_dir.no_addr = sdp->md.rooti->i_addr;
- sb.sb_root_dir.no_formal_ino = sdp->md.rooti->i_formal_ino;
- lgfs2_sb_write(&sb, sdp->device_fd, sdp->bsize);
+ sdp->sd_fs_format = GFS2_FORMAT_FS;
+ lgfs2_sb_write(sdp, sdp->device_fd);
inode_put(&sdp->md.rooti);
inode_put(&sdp->master_dir);
sb_fixed = 1;
@@ -1366,24 +1356,10 @@ static int fill_super_block(struct gfs2_sbd *sdp)
sync();
- /********************************************************************
- ***************** First, initialize all lists **********************
- ********************************************************************/
log_info( _("Initializing lists...\n"));
sdp->rgtree.osi_node = NULL;
- /********************************************************************
- ************ next, read in on-disk SB and set constants **********
- ********************************************************************/
- sdp->sd_sb.sb_bsize = GFS2_DEFAULT_BSIZE;
- sdp->bsize = sdp->sd_sb.sb_bsize;
-
- if (sizeof(struct gfs2_sb) > sdp->sd_sb.sb_bsize){
- log_crit( _("GFS superblock is larger than the blocksize!\n"));
- log_debug("sizeof(struct gfs2_sb) > sdp->sd_sb.sb_bsize\n");
- return FSCK_ERROR;
- }
-
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
if (compute_constants(sdp)) {
log_crit("%s\n", _("Failed to compute file system constants"));
return FSCK_ERROR;
@@ -1397,10 +1373,8 @@ static int fill_super_block(struct gfs2_sbd *sdp)
if (ret < 0)
return FSCK_ERROR;
}
- if (sdp->gfs1)
- sbd1 = (struct gfs_sb *)&sdp->sd_sb;
- else if (sdp->sd_sb.sb_fs_format > FSCK_MAX_FORMAT) {
- log_crit(_("Unsupported gfs2 format found: %"PRIu32"\n"), sdp->sd_sb.sb_fs_format);
+ if (!sdp->gfs1 && sdp->sd_fs_format > FSCK_MAX_FORMAT) {
+ log_crit(_("Unsupported gfs2 format found: %"PRIu32"\n"), sdp->sd_fs_format);
log_crit(_("A newer fsck.gfs2 is required to check this file system.\n"));
return FSCK_USAGE;
}
@@ -1455,11 +1429,11 @@ static int reconstruct_single_journal(struct gfs2_sbd *sdp, int jnum,
lh.lh_header.mh_format = GFS2_FORMAT_LH;
lh.lh_header.__pad0 = 0x101674; /* mh_generation */
lh.lh_flags = GFS2_LOG_HEAD_UNMOUNT;
- lh.lh_first = sdp->md.journal[jnum]->i_addr + (seg * sbd1->sb_seg_size);
+ lh.lh_first = sdp->md.journal[jnum]->i_addr + (seg * sdp->sd_seg_size);
lh.lh_sequence = sequence;
- bh = bget(sdp, lh.lh_first * sdp->bsize);
- memset(bh->b_data, 0, sdp->bsize);
+ bh = bget(sdp, lh.lh_first * sdp->sd_bsize);
+ memset(bh->b_data, 0, sdp->sd_bsize);
gfs_log_header_out(&lh, bh->b_data);
gfs_log_header_out(&lh, bh->b_data + GFS2_BASIC_BLOCK -
sizeof(struct gfs_log_header));
@@ -1471,21 +1445,20 @@ static int reconstruct_single_journal(struct gfs2_sbd *sdp, int jnum,
return 0;
}
-static int reset_journal_seg_size(unsigned int jsize, unsigned int nsegs,
- unsigned int bsize)
+static int reset_journal_seg_size(struct gfs2_sbd *sdp, unsigned int jsize, unsigned int nsegs)
{
- unsigned int seg_size = jsize / (nsegs * bsize);
+ unsigned int seg_size = jsize / (nsegs * sdp->sd_bsize);
if (!seg_size)
seg_size = 16; /* The default with 128MB journal and 4K bsize */
- if (seg_size != sbd1->sb_seg_size) {
- sbd1->sb_seg_size = seg_size;
+ if (seg_size != sdp->sd_seg_size) {
+ sdp->sd_seg_size = seg_size;
if (!query(_("Computed correct journal segment size to %u."
" Reset it? (y/n) "), seg_size)) {
log_crit(_("Error: Cannot proceed without a valid journal"
" segment size value.\n"));
return -1;
}
- log_err(_("Resetting journal segment size to %u\n"), sbd1->sb_seg_size);
+ log_err(_("Resetting journal segment size to %u\n"), sdp->sd_seg_size);
}
return 0;
}
@@ -1506,7 +1479,7 @@ static int correct_journal_seg_size(struct gfs2_sbd *sdp)
gfs_jindex_in(&ji_0, buf);
if (sdp->md.journals == 1) {
- if (sbd1->sb_seg_size == 0) {
+ if (sdp->sd_seg_size == 0) {
if (!query(_("The gfs2 journal segment size is 0 and a"
" correct value cannot be determined in a"
" single-journal filesystem.\n"
@@ -1532,9 +1505,9 @@ static int correct_journal_seg_size(struct gfs2_sbd *sdp)
}
gfs_jindex_in(&ji_1, buf);
- jsize = (ji_1.ji_addr - ji_0.ji_addr) * sbd1->sb_bsize;
+ jsize = (ji_1.ji_addr - ji_0.ji_addr) * sdp->sd_bsize;
out:
- return reset_journal_seg_size(jsize, ji_0.ji_nsegment, sbd1->sb_bsize);
+ return reset_journal_seg_size(sdp, jsize, ji_0.ji_nsegment);
}
/*
@@ -1580,7 +1553,7 @@ static int init_rindex(struct gfs2_sbd *sdp)
int err;
if (sdp->gfs1)
- sdp->md.riinode = lgfs2_inode_read(sdp, sbd1->sb_rindex_di.no_addr);
+ sdp->md.riinode = lgfs2_inode_read(sdp, sdp->sd_rindex_di.no_addr);
else
gfs2_lookupi(sdp->master_dir, "rindex", 6, &sdp->md.riinode);
@@ -1669,16 +1642,14 @@ int initialize(struct gfs2_sbd *sdp, int force_check, int preen,
if (sdp->gfs1)
sdp->master_dir = NULL;
else
- sdp->master_dir = lgfs2_inode_read(sdp,
- sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
if (!sdp->gfs1 &&
(sdp->master_dir->i_magic != GFS2_MAGIC ||
sdp->master_dir->i_type != GFS2_METATYPE_DI ||
!sdp->master_dir->i_size)) {
inode_put(&sdp->master_dir);
rebuild_master(sdp);
- sdp->master_dir = lgfs2_inode_read(sdp,
- sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
if (sdp->master_dir == NULL) {
log_crit(_("Error reading master directory: %s\n"), strerror(errno));
return FSCK_ERROR;
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 2543e2e5..b699ca8d 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -322,13 +322,13 @@ static int dirent_repair(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
/* If this is a sentinel, just fix the length and move on */
if (first && !de->de_inum.no_formal_ino) { /* Is it a sentinel? */
if (type == DIR_LINEAR)
- de->de_rec_len = ip->i_sbd->bsize -
+ de->de_rec_len = ip->i_sbd->sd_bsize -
sizeof(struct gfs2_dinode);
else
- de->de_rec_len = ip->i_sbd->bsize -
+ de->de_rec_len = ip->i_sbd->sd_bsize -
sizeof(struct gfs2_leaf);
} else {
- bh_end = bh->b_data + ip->i_sbd->bsize;
+ bh_end = bh->b_data + ip->i_sbd->sd_bsize;
/* first, figure out a probable name length */
p = (char *)dent + sizeof(struct gfs2_dirent);
while (*p && /* while there's a non-zero char and */
@@ -361,7 +361,7 @@ static void dirblk_truncate(struct gfs2_inode *ip, struct gfs2_dirent *fixb,
char *bh_end;
struct gfs2_dirent de;
- bh_end = bh->b_data + ip->i_sbd->sd_sb.sb_bsize;
+ bh_end = bh->b_data + ip->i_sbd->sd_bsize;
/* truncate the block to save the most dentries. To do this we
have to patch the previous dent. */
gfs2_dirent_in(&de, (char *)fixb);
@@ -394,7 +394,7 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
char *filename;
int first = 1;
- bh_end = bh->b_data + ip->i_sbd->bsize;
+ bh_end = bh->b_data + ip->i_sbd->sd_bsize;
if (type == DIR_LINEAR) {
dent = (struct gfs2_dirent *)(bh->b_data + sizeof(struct gfs2_dinode));
@@ -673,11 +673,11 @@ static void dir_leaf_reada(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize)
for (i = 0; i < hsize; i++) {
leaf_no = be64_to_cpu(tbl[i]);
if (valid_block_ip(ip, leaf_no))
- t[n++] = leaf_no * sdp->bsize;
+ t[n++] = leaf_no * sdp->sd_bsize;
}
qsort(t, n, sizeof(uint64_t), u64cmp);
for (i = 0; i < n; i++)
- posix_fadvise(sdp->device_fd, t[i], sdp->bsize, POSIX_FADV_WILLNEED);
+ posix_fadvise(sdp->device_fd, t[i], sdp->sd_bsize, POSIX_FADV_WILLNEED);
}
/* Checks exhash directory entries */
@@ -890,14 +890,14 @@ static int check_eattr_entries(struct gfs2_inode *ip,
pass->private);
if (err)
error = err;
- tot_ealen += sdp->sd_sb.sb_bsize -
+ tot_ealen += sdp->sd_bsize -
sizeof(struct gfs2_meta_header);
ea_data_ptr++;
}
}
offset += be32_to_cpu(ea_hdr->ea_rec_len);
if (ea_hdr->ea_flags & GFS2_EAFLAG_LAST ||
- offset >= ip->i_sbd->sd_sb.sb_bsize || ea_hdr->ea_rec_len == 0){
+ offset >= ip->i_sbd->sd_bsize || ea_hdr->ea_rec_len == 0){
break;
}
ea_hdr_prev = ea_hdr;
@@ -970,7 +970,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect,
int leaf_pointers = 0, leaf_pointer_errors = 0;
ea_leaf_ptr = (uint64_t *)(indirect_buf->b_data + offset);
- end = ea_leaf_ptr + ((sdp->sd_sb.sb_bsize - offset) / 8);
+ end = ea_leaf_ptr + ((sdp->sd_bsize - offset) / 8);
while (*ea_leaf_ptr && (ea_leaf_ptr < end)){
block = be64_to_cpu(*ea_leaf_ptr);
@@ -1123,8 +1123,8 @@ static void file_ra(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
extlen = block - sblock;
if (extlen > 1 && extlen <= maxptrs) {
posix_fadvise(sdp->device_fd,
- sblock * sdp->bsize,
- (extlen + 1) * sdp->bsize,
+ sblock * sdp->sd_bsize,
+ (extlen + 1) * sdp->sd_bsize,
POSIX_FADV_WILLNEED);
return;
}
@@ -1132,7 +1132,7 @@ static void file_ra(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
extlen = 0;
}
for (p = (uint64_t *)(bh->b_data + head_size);
- p < (uint64_t *)(bh->b_data + sdp->bsize); p++) {
+ p < (uint64_t *)(bh->b_data + sdp->sd_bsize); p++) {
if (*p) {
if (!sblock) {
sblock = be64_to_cpu(*p);
@@ -1148,16 +1148,16 @@ static void file_ra(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
if (extlen && sblock) {
if (extlen > 1)
extlen--;
- posix_fadvise(sdp->device_fd, sblock * sdp->bsize,
- extlen * sdp->bsize,
+ posix_fadvise(sdp->device_fd, sblock * sdp->sd_bsize,
+ extlen * sdp->sd_bsize,
POSIX_FADV_WILLNEED);
extlen = 0;
p--;
}
}
if (extlen)
- posix_fadvise(sdp->device_fd, sblock * sdp->bsize,
- extlen * sdp->bsize, POSIX_FADV_WILLNEED);
+ posix_fadvise(sdp->device_fd, sblock * sdp->sd_bsize,
+ extlen * sdp->sd_bsize, POSIX_FADV_WILLNEED);
}
static int do_check_metalist(struct iptr iptr, int height, struct gfs2_buffer_head **bhp,
@@ -1252,7 +1252,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
iblk_type = GFS2_METATYPE_IN;
if (ip->i_sbd->gfs1) {
head_size = sizeof(struct gfs_indirect);
- maxptrs = (ip->i_sbd->bsize - head_size) /
+ maxptrs = (ip->i_sbd->sd_bsize - head_size) /
sizeof(uint64_t);
} else {
head_size = sizeof(struct gfs2_meta_header);
@@ -1280,7 +1280,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
file_ra(ip, iptr.ipt_bh, head_size, maxptrs, h);
/* Now check the metadata itself */
- for (; iptr.ipt_off < ip->i_sbd->bsize; iptr.ipt_off += sizeof(uint64_t)) {
+ for (; iptr.ipt_off < ip->i_sbd->sd_bsize; iptr.ipt_off += sizeof(uint64_t)) {
struct gfs2_buffer_head *nbh = NULL;
if (skip_this_pass || fsck_abort)
@@ -1398,7 +1398,7 @@ static int metawalk_check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass
int error = 0, rc = 0;
uint64_t block;
__be64 *ptr_start = (uint64_t *)(bh->b_data + hdr_size(bh, height));
- __be64 *ptr_end = (uint64_t *)(bh->b_data + ip->i_sbd->bsize);
+ __be64 *ptr_end = (uint64_t *)(bh->b_data + ip->i_sbd->sd_bsize);
__be64 *ptr;
uint64_t metablock = bh->b_blocknr;
@@ -1464,7 +1464,7 @@ static int undo_check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass,
struct error_block *error_blk, int error)
{
__be64 *ptr_start = (uint64_t *)(bh->b_data + hdr_size(bh, height));
- __be64 *ptr_end = (uint64_t *)(bh->b_data + ip->i_sbd->bsize);
+ __be64 *ptr_end = (uint64_t *)(bh->b_data + ip->i_sbd->sd_bsize);
__be64 *ptr;
uint64_t metablock = bh->b_blocknr;
int rc = 0;
diff --git a/gfs2/fsck/metawalk.h b/gfs2/fsck/metawalk.h
index f63ed5cf..f6c6bc31 100644
--- a/gfs2/fsck/metawalk.h
+++ b/gfs2/fsck/metawalk.h
@@ -50,7 +50,7 @@ struct iptr {
#define iptr_ptr(i) ((uint64_t *)(i.ipt_bh->b_data + i.ipt_off))
#define iptr_block(i) be64_to_cpu(*iptr_ptr(i))
-#define iptr_endptr(i) ((uint64_t *)(iptr.ipt_bh->b_data + i.ipt_ip->i_sbd->bsize))
+#define iptr_endptr(i) ((uint64_t *)(iptr.ipt_bh->b_data + i.ipt_ip->i_sbd->sd_bsize))
#define iptr_buf(i) (i.ipt_bh->b_data)
/* metawalk_fxns: function pointers to check various parts of the fs
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index f2ba4235..047a96b0 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -898,7 +898,7 @@ static int ask_remove_eattr_entry(struct gfs2_sbd *sdp,
if (fix_curr)
curr->ea_flags |= GFS2_EAFLAG_LAST;
if (fix_curr_len) {
- uint32_t max_size = sdp->sd_sb.sb_bsize;
+ uint32_t max_size = sdp->sd_bsize;
uint32_t offset = (uint32_t)(((unsigned long)curr) -
((unsigned long)leaf_bh->b_data));
curr->ea_rec_len = cpu_to_be32(max_size - offset);
@@ -938,7 +938,7 @@ static int check_eattr_entries(struct gfs2_inode *ip,
char ea_name[256];
uint32_t offset = (uint32_t)(((unsigned long)ea_hdr) -
((unsigned long)leaf_bh->b_data));
- uint32_t max_size = sdp->sd_sb.sb_bsize;
+ uint32_t max_size = sdp->sd_bsize;
uint32_t avail_size;
int max_ptrs;
@@ -968,11 +968,11 @@ static int check_eattr_entries(struct gfs2_inode *ip,
strncpy(ea_name, (char *)ea_hdr + sizeof(struct gfs2_ea_header),
ea_hdr->ea_name_len);
- if (ea_hdr->ea_type > eatype_max(sdp->sd_sb.sb_fs_format) &&
+ if (ea_hdr->ea_type > eatype_max(sdp->sd_fs_format) &&
((ea_hdr_prev) || (!ea_hdr_prev && ea_hdr->ea_type))){
/* Skip invalid entry */
log_err(_("EA (%s) type is invalid (%d > %d).\n"),
- ea_name, ea_hdr->ea_type, eatype_max(sdp->sd_sb.sb_fs_format));
+ ea_name, ea_hdr->ea_type, eatype_max(sdp->sd_fs_format));
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 0, 0);
}
@@ -980,7 +980,7 @@ static int check_eattr_entries(struct gfs2_inode *ip,
if (!ea_hdr->ea_num_ptrs)
return 0;
- avail_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
+ avail_size = sdp->sd_bsize - sizeof(struct gfs2_meta_header);
max_ptrs = (be32_to_cpu(ea_hdr->ea_data_len)+avail_size-1)/avail_size;
if (max_ptrs > ea_hdr->ea_num_ptrs) {
@@ -1812,7 +1812,7 @@ static int pass1_process_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd, uin
int q;
/* Readahead numbers arrived at by experiment */
unsigned rawin = 50;
- unsigned ralen = 100 * sdp->bsize;
+ unsigned ralen = 100 * sdp->sd_bsize;
unsigned r = 0;
for (i = 0; i < n; i++) {
@@ -1822,7 +1822,7 @@ static int pass1_process_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd, uin
block = ibuf[i];
if (r++ == rawin) {
- posix_fadvise(sdp->device_fd, block * sdp->bsize, ralen, POSIX_FADV_WILLNEED);
+ posix_fadvise(sdp->device_fd, block * sdp->sd_bsize, ralen, POSIX_FADV_WILLNEED);
r = 0;
}
@@ -1938,7 +1938,7 @@ static int pass1_process_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd, uin
static int pass1_process_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
{
unsigned k, n, i;
- uint64_t *ibuf = malloc(sdp->bsize * GFS2_NBBY * sizeof(uint64_t));
+ uint64_t *ibuf = malloc(sdp->sd_bsize * GFS2_NBBY * sizeof(uint64_t));
int ret = 0;
if (ibuf == NULL)
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index d5fe61b3..d8d08056 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -1017,7 +1017,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
dip->i_blocks++;
bmodified(dip->i_bh);
nbh = bget(dip->i_sbd, *bn);
- memset(nbh->b_data, 0, dip->i_sbd->bsize);
+ memset(nbh->b_data, 0, dip->i_sbd->sd_bsize);
leaf = (struct gfs2_leaf *)nbh->b_data;
leaf->lf_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
leaf->lf_header.mh_type = cpu_to_be32(GFS2_METATYPE_LF);
@@ -1026,7 +1026,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
/* initialize the first dirent on the new leaf block */
dent = (struct gfs2_dirent *)(nbh->b_data + sizeof(struct gfs2_leaf));
- dent->de_rec_len = cpu_to_be16(dip->i_sbd->bsize -
+ dent->de_rec_len = cpu_to_be16(dip->i_sbd->sd_bsize -
sizeof(struct gfs2_leaf));
bmodified(nbh);
brelse(nbh);
@@ -1119,7 +1119,7 @@ static int lost_leaf(struct gfs2_inode *ip, uint64_t *tbl, uint64_t leafno,
int ref_count, int lindex, struct gfs2_buffer_head *bh)
{
char *filename;
- char *bh_end = bh->b_data + ip->i_sbd->bsize;
+ char *bh_end = bh->b_data + ip->i_sbd->sd_bsize;
struct gfs2_dirent de, *dent;
int error;
int isdir = 0;
@@ -1382,7 +1382,7 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize,
gfs2_dirent_in(&dentry, (char *)de);
/* If this is an empty leaf, we can just delete it and pad. */
- if ((dentry.de_rec_len == cpu_to_be16(ip->i_sbd->bsize -
+ if ((dentry.de_rec_len == cpu_to_be16(ip->i_sbd->sd_bsize -
sizeof(struct gfs2_leaf))) &&
(dentry.de_inum.no_formal_ino == 0)) {
brelse(lbh);
diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c
index 029f0711..fbdc4f34 100644
--- a/gfs2/fsck/rgrepair.c
+++ b/gfs2/fsck/rgrepair.c
@@ -60,7 +60,7 @@ static void find_journaled_rgs(struct gfs2_sbd *sdp)
ip = sdp->md.journal[j];
log_debug(_("Checking for rgrps in journal%d which starts at block 0x%"PRIx64".\n"),
j, ip->i_addr);
- jblocks = ip->i_size / sdp->sd_sb.sb_bsize;
+ jblocks = ip->i_size / sdp->sd_bsize;
false_count = 0;
for (b = 0; b < jblocks; b++) {
block_map(ip, b, &new, &dblock, NULL, 0);
@@ -276,7 +276,7 @@ static uint64_t count_usedspace(struct gfs2_sbd *sdp, int first,
off = sizeof(struct gfs2_rgrp);
} else
off = sizeof(struct gfs2_meta_header);
- bytes_to_check = sdp->bsize - off;
+ bytes_to_check = sdp->sd_bsize - off;
for (x = 0; x < bytes_to_check; x++) {
unsigned char *byte;
@@ -336,7 +336,7 @@ static uint64_t find_next_rgrp_dist(struct gfs2_sbd *sdp, uint64_t blk,
rgrp_dist = next_rgd->rt_addr - rgd->rt_addr;
return rgrp_dist;
}
- mega_in_blocks = (1024 * 1024) / sdp->bsize;
+ mega_in_blocks = (1024 * 1024) / sdp->sd_bsize;
twogigs = (uint64_t)mega_in_blocks * 2048;
/* Unfortunately, if we fall through to here we can't trust the
rindex. So we have to analyze the current rgrp to figure out
@@ -453,7 +453,7 @@ static uint64_t hunt_and_peck(struct gfs2_sbd *sdp, uint64_t blk,
/* 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. */
- mega_in_blocks = (1024 * 1024) / sdp->bsize;
+ mega_in_blocks = (1024 * 1024) / sdp->sd_bsize;
twogigs = 2048 * mega_in_blocks;
if (block + twogigs <= sdp->fssize) {
last_block = twogigs;
@@ -599,7 +599,7 @@ static int rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs, int gfs_grow)
if (prev_rgd) {
uint32_t rgblocks;
- prev_rgd->rt_length = rgblocks2bitblocks(sdp->bsize, block_bump, &rgblocks);
+ prev_rgd->rt_length = rgblocks2bitblocks(sdp->sd_bsize, block_bump, &rgblocks);
prev_rgd->rt_data = rgblocks;
prev_rgd->rt_data0 = prev_rgd->rt_addr +
prev_rgd->rt_length;
@@ -661,7 +661,7 @@ static int rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs, int gfs_grow)
if (prev_rgd && !prev_rgd->rt_data) {
uint32_t rgblocks;
- prev_rgd->rt_length = rgblocks2bitblocks(sdp->bsize, block_bump, &rgblocks);
+ prev_rgd->rt_length = rgblocks2bitblocks(sdp->sd_bsize, block_bump, &rgblocks);
prev_rgd->rt_data0 = prev_rgd->rt_addr + prev_rgd->rt_length;
prev_rgd->rt_data = rgblocks;
prev_rgd->rt_data -= prev_rgd->rt_data % GFS2_NBBY;
@@ -707,12 +707,12 @@ static uint64_t how_many_rgrps(struct gfs2_sbd *sdp, struct device *dev, int rgs
int bitmap_overflow = 0;
while (1) {
- nrgrp = DIV_RU(dev->length, (sdp->rgsize << 20) / sdp->bsize);
+ nrgrp = DIV_RU(dev->length, (sdp->rgsize << 20) / sdp->sd_bsize);
/* check to see if the rg length overflows max # bitblks */
- bitblocksn = rgblocks2bitblocks(sdp->bsize, dev->length / nrgrp, &rgblocksn);
+ bitblocksn = rgblocks2bitblocks(sdp->sd_bsize, dev->length / nrgrp, &rgblocksn);
/* calculate size of the first rgrp */
- bitblocks1 = rgblocks2bitblocks(sdp->bsize, dev->length - (nrgrp - 1) * (dev->length / nrgrp),
+ bitblocks1 = rgblocks2bitblocks(sdp->sd_bsize, dev->length - (nrgrp - 1) * (dev->length / nrgrp),
&rgblocks1);
if (bitblocks1 > 2149 || bitblocksn > 2149) {
bitmap_overflow = 1;
@@ -720,7 +720,7 @@ static uint64_t how_many_rgrps(struct gfs2_sbd *sdp, struct device *dev, int rgs
fprintf(stderr, "error: It is not possible "
"to use the entire device with "
"block size %u bytes.\n",
- sdp->bsize);
+ sdp->sd_bsize);
exit(-1);
}
sdp->rgsize -= GFS2_DEFAULT_RGSIZE; /* smaller rgs */
@@ -820,7 +820,7 @@ static int calc_rgrps(struct gfs2_sbd *sdp)
next = osi_next(n);
rl = (struct rgrp_tree *)n;
- bitblocks = rgblocks2bitblocks(sdp->bsize, rl->length, &rgblocks);
+ bitblocks = rgblocks2bitblocks(sdp->sd_bsize, rl->length, &rgblocks);
rl->rt_addr = rl->start;
rl->rt_length = bitblocks;
@@ -829,7 +829,7 @@ static int calc_rgrps(struct gfs2_sbd *sdp)
rl->rt_bitbytes = rgblocks / GFS2_NBBY;
rl->rt_free = rgblocks;
- if (gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, rl))
+ if (gfs2_compute_bitstructs(sdp->sd_bsize, rl))
return -1;
sdp->blks_total += rgblocks;
@@ -909,13 +909,13 @@ static int rewrite_rg_block(struct gfs2_sbd *sdp, struct rgrp_tree *rg,
log_err(_("Attempting to repair the resource group.\n"));
- buf = calloc(1, sdp->bsize);
+ buf = calloc(1, sdp->sd_bsize);
if (buf == NULL) {
log_err(_("Failed to allocate resource group block: %s"), strerror(errno));
return 1;
}
- ret = pread(sdp->device_fd, buf, sdp->bsize, errblock * sdp->bsize);
- if (ret != sdp->bsize) {
+ ret = pread(sdp->device_fd, buf, sdp->sd_bsize, errblock * sdp->sd_bsize);
+ if (ret != sdp->sd_bsize) {
log_err(_("Failed to read resource group block %"PRIu64": %s\n"),
errblock, strerror(errno));
free(buf);
@@ -935,8 +935,8 @@ static int rewrite_rg_block(struct gfs2_sbd *sdp, struct rgrp_tree *rg,
else
lgfs2_rgrp_out(rg, buf);
}
- ret = pwrite(sdp->device_fd, buf, sdp->bsize, errblock * sdp->bsize);
- if (ret != sdp->bsize) {
+ ret = pwrite(sdp->device_fd, buf, sdp->sd_bsize, errblock * sdp->sd_bsize);
+ if (ret != sdp->sd_bsize) {
log_err(_("Failed to write resource group block %"PRIu64": %s\n"),
errblock, strerror(errno));
free(buf);
@@ -977,7 +977,7 @@ static int expect_rindex_sanity(struct gfs2_sbd *sdp, int *num_rgs)
exp->rt_dinodes = rgd->rt_dinodes;
exp->rt_skip = rgd->rt_skip;
exp->bits = NULL;
- gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, exp);
+ gfs2_compute_bitstructs(sdp->sd_bsize, exp);
}
sdp->rgrps = *num_rgs;
return 0;
@@ -1213,7 +1213,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok)
}
else
log_err( _("rindex not fixed.\n"));
- gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, actual);
+ gfs2_compute_bitstructs(sdp->sd_bsize, actual);
rindex_modified = 0;
}
e = enext;
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index dfc4512c..962ec1e0 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -44,7 +44,7 @@ void big_file_comfort(struct gfs2_inode *ip, uint64_t blks_checked)
fsize = ip->i_size;
for (i = 0; i < 6 && fsize > 1024; i++)
fsize /= 1024;
- chksize = blks_checked * ip->i_sbd->bsize;
+ chksize = blks_checked * ip->i_sbd->sd_bsize;
for (cs = 0; cs < 6 && chksize > 1024; cs++)
chksize /= 1024;
seconds = tv.tv_sec;
@@ -563,7 +563,7 @@ uint64_t find_free_blk(struct gfs2_sbd *sdp)
char *buf = rl->bits[block].bi_data;
x = (block) ? sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_rgrp);
- for (; x < sdp->bsize; x++)
+ for (; x < sdp->sd_bsize; x++)
for (y = 0; y < GFS2_NBBY; y++) {
state = (buf[x] >> (GFS2_BIT_SIZE * y)) & 0x03;
if (state == GFS2_BLKST_FREE)
diff --git a/gfs2/glocktop/glocktop.c b/gfs2/glocktop/glocktop.c
index c0fc0ceb..e7282517 100644
--- a/gfs2/glocktop/glocktop.c
+++ b/gfs2/glocktop/glocktop.c
@@ -156,7 +156,7 @@ struct mount_point {
char *device;
char *dir;
int fd;
- struct gfs2_sb sb;
+ struct gfs2_sbd sb;
};
struct mount_point *mounts;
char dlmwlines[MAX_LINES][96]; /* waiters lines */
@@ -223,7 +223,7 @@ static void UpdateSize(int sig)
signal(SIGWINCH, UpdateSize);
}
-static int read_superblock(int fd, struct gfs2_sb *sb)
+static int read_superblock(int fd, struct gfs2_sbd *sdp)
{
ssize_t r;
char *buf;
@@ -240,10 +240,10 @@ static int read_superblock(int fd, struct gfs2_sb *sb)
free(buf);
return -1;
}
- gfs2_sb_in(sb, buf);
+ lgfs2_sb_in(sdp, buf);
free(buf);
- bsize = sb->sb_bsize;
+ bsize = sdp->sd_bsize;
if (!bsize)
bsize = 4096;
return 0;
@@ -618,7 +618,7 @@ static const char *show_inode(const char *id, int fd, unsigned long long block)
{
struct gfs2_inode *ip;
const char *inode_type = NULL;
- struct gfs2_sbd sbd = { .device_fd = fd, .bsize = bsize };
+ struct gfs2_sbd sbd = { .device_fd = fd, .sd_bsize = bsize };
ip = lgfs2_inode_read(&sbd, block);
if (S_ISDIR(ip->i_mode)) {
@@ -674,7 +674,7 @@ static const char *show_details(const char *id, const char *fsname, int btype,
for (mp = mounts; mp != NULL; mp = mp->next) {
char *p;
- p = strchr(mp->sb.sb_locktable, ':');
+ p = strchr(mp->sb.sd_locktable, ':');
if (!p)
continue;
p++;
@@ -686,7 +686,7 @@ static const char *show_details(const char *id, const char *fsname, int btype,
memset(dlm_dirtbl_size, 0, sizeof(dlm_dirtbl_size));
memset(dlm_rsbtbl_size, 0, sizeof(dlm_rsbtbl_size));
memset(dlm_lkbtbl_size, 0, sizeof(dlm_lkbtbl_size));
- if (!strcmp(mp->sb.sb_lockproto, "lock_dlm")) {
+ if (!strcmp(mp->sb.sd_lockproto, "lock_dlm")) {
char *sp;
char *p;
diff --git a/gfs2/libgfs2/buf.c b/gfs2/libgfs2/buf.c
index 22144d68..e317625f 100644
--- a/gfs2/libgfs2/buf.c
+++ b/gfs2/libgfs2/buf.c
@@ -26,14 +26,14 @@ struct gfs2_buffer_head *bget(struct gfs2_sbd *sdp, uint64_t num)
{
struct gfs2_buffer_head *bh;
- bh = calloc(1, sizeof(struct gfs2_buffer_head) + sdp->bsize);
+ bh = calloc(1, sizeof(struct gfs2_buffer_head) + sdp->sd_bsize);
if (bh == NULL)
return NULL;
bh->b_blocknr = num;
bh->sdp = sdp;
bh->iov.iov_base = (char *)bh + sizeof(struct gfs2_buffer_head);
- bh->iov.iov_len = sdp->bsize;
+ bh->iov.iov_len = sdp->sd_bsize;
return bh;
}
@@ -59,7 +59,7 @@ int __breadm(struct gfs2_sbd *sdp, struct gfs2_buffer_head **bhs, size_t n,
size += bhs[i + j]->iov.iov_len;
}
- ret = preadv(sdp->device_fd, iovbase, j, (block + i) * sdp->bsize);
+ ret = preadv(sdp->device_fd, iovbase, j, (block + i) * sdp->sd_bsize);
if (ret != size) {
fprintf(stderr, "bad read: %s from %s:%d: block %llu (0x%llx) "
"count: %d size: %zd ret: %zd\n", strerror(errno),
@@ -82,8 +82,8 @@ struct gfs2_buffer_head *__bread(struct gfs2_sbd *sdp, uint64_t num, int line,
if (bh == NULL)
return NULL;
- ret = pread(sdp->device_fd, bh->b_data, sdp->bsize, num * sdp->bsize);
- if (ret != sdp->bsize) {
+ ret = pread(sdp->device_fd, bh->b_data, sdp->sd_bsize, num * sdp->sd_bsize);
+ if (ret != sdp->sd_bsize) {
fprintf(stderr, "%s:%d: Error reading block %"PRIu64": %s\n",
caller, line, num, strerror(errno));
free(bh);
@@ -96,7 +96,7 @@ int bwrite(struct gfs2_buffer_head *bh)
{
struct gfs2_sbd *sdp = bh->sdp;
- if (pwritev(sdp->device_fd, &bh->iov, 1, bh->b_blocknr * sdp->bsize) != bh->iov.iov_len)
+ if (pwritev(sdp->device_fd, &bh->iov, 1, bh->b_blocknr * sdp->sd_bsize) != bh->iov.iov_len)
return -1;
bh->b_modified = 0;
return 0;
diff --git a/gfs2/libgfs2/check_rgrp.c b/gfs2/libgfs2/check_rgrp.c
index dd31a341..5178c7a7 100644
--- a/gfs2/libgfs2/check_rgrp.c
+++ b/gfs2/libgfs2/check_rgrp.c
@@ -34,7 +34,7 @@ static void mockup_rgrps(void)
ck_assert(unlink(tmpnam) == 0);
ck_assert(ftruncate(sdp->device_fd, MOCK_DEV_SIZE) == 0);
- sdp->bsize = sdp->sd_sb.sb_bsize = 4096;
+ sdp->sd_bsize = 4096;
compute_constants(sdp);
rgs = lgfs2_rgrps_init(sdp, 0, 0);
@@ -115,7 +115,7 @@ START_TEST(test_rbm_find_lastblock)
/* Flag all blocks as allocated... */
for (i = 0; i < rg->rt_length; i++)
- memset(rg->bits[i].bi_data, 0xff, rgs->sdp->bsize);
+ memset(rg->bits[i].bi_data, 0xff, rgs->sdp->sd_bsize);
/* ...except the final one */
err = gfs2_set_bitmap(rg, rg->rt_data0 + rg->rt_data - 1, GFS2_BLKST_FREE);
diff --git a/gfs2/libgfs2/device_geometry.c b/gfs2/libgfs2/device_geometry.c
index 72f9c7e4..4a0aeab2 100644
--- a/gfs2/libgfs2/device_geometry.c
+++ b/gfs2/libgfs2/device_geometry.c
@@ -97,7 +97,7 @@ void fix_device_geometry(struct gfs2_sbd *sdp)
{
struct device *device = &sdp->device;
- device->length = sdp->dinfo.size / sdp->bsize;
+ device->length = sdp->dinfo.size / sdp->sd_bsize;
if (cfg_debug) {
printf("\nDevice Geometry: (in FS blocks)\n");
diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index c0569257..f7205393 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
@@ -219,7 +219,7 @@ int lgfs2_meta_alloc(struct gfs2_inode *ip, uint64_t *blkno)
static __inline__ void buffer_clear_tail(struct gfs2_sbd *sdp,
struct gfs2_buffer_head *bh, int head)
{
- memset(bh->b_data + head, 0, sdp->bsize - head);
+ memset(bh->b_data + head, 0, sdp->sd_bsize - head);
bmodified(bh);
}
@@ -229,8 +229,8 @@ buffer_copy_tail(struct gfs2_sbd *sdp,
struct gfs2_buffer_head *from_bh, int from_head)
{
memcpy(to_bh->b_data + to_head, from_bh->b_data + from_head,
- sdp->bsize - from_head);
- memset(to_bh->b_data + sdp->bsize + to_head - from_head, 0,
+ sdp->sd_bsize - from_head);
+ memset(to_bh->b_data + sdp->sd_bsize + to_head - from_head, 0,
from_head - to_head);
bmodified(to_bh);
}
@@ -316,7 +316,7 @@ int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct gfs2_inode *ip, u
unsigned extlen;
struct gfs2_sbd *sdp = rg->rgrps->sdp;
struct lgfs2_rbm rbm = { .rgd = rg, .offset = 0, .bii = 0 };
- uint32_t blocks = lgfs2_space_for_data(sdp, sdp->bsize, di_size);
+ uint32_t blocks = lgfs2_space_for_data(sdp, sdp->sd_bsize, di_size);
if (ip->i_addr != 0) {
if (lgfs2_rbm_from_block(&rbm, ip->i_addr) != 0)
@@ -344,7 +344,7 @@ int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct gfs2_inode *ip, u
ip->i_blocks = blocks;
ip->i_atime = ip->i_mtime = ip->i_ctime = sdp->time;
ip->i_goal_data = ip->i_addr + ip->i_blocks - 1;
- ip->i_goal_meta = ip->i_goal_data - ((di_size + sdp->bsize - 1) / sdp->bsize);
+ ip->i_goal_meta = ip->i_goal_data - ((di_size + sdp->sd_bsize - 1) / sdp->sd_bsize);
ip->i_height = calc_tree_height(ip, di_size);
ip->i_flags = flags;
@@ -491,7 +491,7 @@ void block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
return;
}
- bsize = (S_ISDIR(ip->i_mode)) ? sdp->sd_jbsize : sdp->bsize;
+ bsize = (S_ISDIR(ip->i_mode)) ? sdp->sd_jbsize : sdp->sd_bsize;
height = calc_tree_height(ip, (lblock + 1) * bsize);
if (ip->i_height < height) {
@@ -600,8 +600,8 @@ int gfs2_readi(struct gfs2_inode *ip, void *buf,
o = lblock % sdp->sd_jbsize;
lblock /= sdp->sd_jbsize;
} else {
- lblock = offset >> sdp->sd_sb.sb_bsize_shift;
- o = offset & (sdp->bsize - 1);
+ lblock = offset >> sdp->sd_bsize_shift;
+ o = offset & (sdp->sd_bsize - 1);
}
if (inode_is_stuffed(ip))
@@ -611,8 +611,8 @@ int gfs2_readi(struct gfs2_inode *ip, void *buf,
while (copied < size) {
amount = size - copied;
- if (amount > sdp->bsize - o)
- amount = sdp->bsize - o;
+ if (amount > sdp->sd_bsize - o)
+ amount = sdp->sd_bsize - o;
if (!extlen) {
if (sdp->gfs1)
@@ -677,7 +677,7 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf,
return 0;
if (inode_is_stuffed(ip) &&
- ((start + size) > (sdp->bsize - sizeof(struct gfs2_dinode))))
+ ((start + size) > (sdp->sd_bsize - sizeof(struct gfs2_dinode))))
unstuff_dinode(ip);
if (isdir) {
@@ -685,8 +685,8 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf,
o = lblock % sdp->sd_jbsize;
lblock /= sdp->sd_jbsize;
} else {
- lblock = offset >> sdp->sd_sb.sb_bsize_shift;
- o = offset & (sdp->bsize - 1);
+ lblock = offset >> sdp->sd_bsize_shift;
+ o = offset & (sdp->sd_bsize - 1);
}
if (inode_is_stuffed(ip))
@@ -696,8 +696,8 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf,
while (copied < size) {
amount = size - copied;
- if (amount > sdp->bsize - o)
- amount = sdp->bsize - o;
+ if (amount > sdp->sd_bsize - o)
+ amount = sdp->sd_bsize - o;
if (!extlen) {
new = 1;
@@ -760,7 +760,7 @@ int gfs2_dirent_next(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,
char *bh_end;
uint16_t cur_rec_len;
- bh_end = bh->b_data + dip->i_sbd->bsize;
+ bh_end = bh->b_data + dip->i_sbd->sd_bsize;
cur_rec_len = be16_to_cpu((*dent)->de_rec_len);
if (cur_rec_len == 0 || (char *)(*dent) + cur_rec_len >= bh_end)
@@ -797,7 +797,7 @@ static int dirent_alloc(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,
}
if (!entries) {
- dent->de_rec_len = cpu_to_be16(dip->i_sbd->bsize - offset);
+ dent->de_rec_len = cpu_to_be16(dip->i_sbd->sd_bsize - offset);
dent->de_name_len = cpu_to_be16(name_len);
bmodified(bh);
*dent_out = dent;
@@ -1042,12 +1042,12 @@ static void dir_double_exhash(struct gfs2_inode *dip)
if (sdp->gfs1)
count = gfs1_writei(dip, (char *)buf +
sdp->sd_hash_bsize,
- block * sdp->bsize, sdp->bsize);
+ block * sdp->sd_bsize, sdp->sd_bsize);
else
count = gfs2_writei(dip, (char *)buf +
sdp->sd_hash_bsize,
- block * sdp->bsize, sdp->bsize);
- if (count != sdp->bsize) {
+ block * sdp->sd_bsize, sdp->sd_bsize);
+ if (count != sdp->sd_bsize) {
fprintf(stderr, "dir_double_exhash (2)\n");
exit(1);
}
@@ -1278,7 +1278,7 @@ static void dir_make_exhash(struct gfs2_inode *dip)
for (x = sdp->sd_hash_ptrs; x--; lp++)
*lp = cpu_to_be64(bn);
- dip->i_size = sdp->bsize / 2;
+ dip->i_size = sdp->sd_bsize / 2;
dip->i_blocks++;
dip->i_flags |= GFS2_DIF_EXHASH;
dip->i_payload_format = 0;
@@ -1379,7 +1379,7 @@ static int __init_dinode(struct gfs2_sbd *sdp, struct gfs2_buffer_head **bhp, st
p += len;
hash = gfs2_disk_hash("..", 2);
- len = sdp->bsize - (p - bh->b_data);
+ len = sdp->sd_bsize - (p - bh->b_data);
de.de_inum.no_formal_ino = cpu_to_be64(parent->no_formal_ino);
de.de_inum.no_addr = cpu_to_be64(parent->no_addr);
de.de_hash = cpu_to_be32(hash);
@@ -1392,7 +1392,7 @@ static int __init_dinode(struct gfs2_sbd *sdp, struct gfs2_buffer_head **bhp, st
*p = '.';
di->di_nlink = cpu_to_be32(2);
- di->di_size = cpu_to_be64(sdp->bsize - sizeof(struct gfs2_dinode));
+ di->di_size = cpu_to_be64(sdp->sd_bsize - sizeof(struct gfs2_dinode));
di->di_flags = cpu_to_be32(flags | GFS2_DIF_JDATA);
di->di_payload_format = cpu_to_be32(GFS2_FORMAT_DE);
di->di_entries = cpu_to_be32(2);
@@ -1430,7 +1430,7 @@ int lgfs2_write_filemeta(struct gfs2_inode *ip)
unsigned height = 0;
struct metapath mp;
struct gfs2_sbd *sdp = ip->i_sbd;
- uint64_t dblocks = (ip->i_size + sdp->bsize - 1) / sdp->bsize;
+ uint64_t dblocks = (ip->i_size + sdp->sd_bsize - 1) / sdp->sd_bsize;
uint64_t ptr0 = ip->i_addr + 1;
unsigned ptrs = 1;
struct gfs2_meta_header mh = {
@@ -1464,7 +1464,7 @@ int lgfs2_write_filemeta(struct gfs2_inode *ip)
start += sizeof(struct gfs2_meta_header);
gfs2_meta_header_out(&mh, bh->b_data);
}
- lgfs2_fill_indir(start, bh->b_data + sdp->bsize, ptr0, ptrs, &p);
+ lgfs2_fill_indir(start, bh->b_data + sdp->sd_bsize, ptr0, ptrs, &p);
if (bwrite(bh)) {
free(bh);
return 1;
@@ -1944,7 +1944,7 @@ int gfs2_freedi(struct gfs2_sbd *sdp, uint64_t diblock)
b_altlist);
for (ptr = (uint64_t *)(bh->b_data + head_size);
- (char *)ptr < (bh->b_data + sdp->bsize); ptr++) {
+ (char *)ptr < (bh->b_data + sdp->sd_bsize); ptr++) {
if (!*ptr)
continue;
diff --git a/gfs2/libgfs2/gfs1.c b/gfs2/libgfs2/gfs1.c
index d1b54a92..4cdf26e5 100644
--- a/gfs2/libgfs2/gfs1.c
+++ b/gfs2/libgfs2/gfs1.c
@@ -93,7 +93,7 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
return;
}
- bsize = (fs_is_jdata(ip)) ? sdp->sd_jbsize : sdp->bsize;
+ bsize = (fs_is_jdata(ip)) ? sdp->sd_jbsize : sdp->sd_bsize;
height = calc_tree_height(ip, (lblock + 1) * bsize);
if (ip->i_height < height) {
@@ -180,15 +180,15 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
return 0;
if (!ip->i_height && /* stuffed */
- ((start + size) > (sdp->bsize - sizeof(struct gfs_dinode))))
+ ((start + size) > (sdp->sd_bsize - sizeof(struct gfs_dinode))))
unstuff_dinode(ip);
if (journaled) {
lblock = offset / sdp->sd_jbsize;
offset %= sdp->sd_jbsize;
} else {
- lblock = offset >> sdp->sd_sb.sb_bsize_shift;
- offset &= sdp->bsize - 1;
+ lblock = offset >> sdp->sd_bsize_shift;
+ offset &= sdp->sd_bsize - 1;
}
if (!ip->i_height) /* stuffed */
@@ -198,8 +198,8 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
while (copied < size) {
amount = size - copied;
- if (amount > sdp->bsize - offset)
- amount = sdp->bsize - offset;
+ if (amount > sdp->sd_bsize - offset)
+ amount = sdp->sd_bsize - offset;
if (!extlen){
new = 1;
@@ -297,7 +297,7 @@ struct gfs2_inode *lgfs2_gfs_inode_read(struct gfs2_sbd *sdp, uint64_t di_addr)
bh = bget(sdp, di_addr);
if (bh == NULL)
return NULL;
- if (pread(sdp->device_fd, bh->b_data, sdp->bsize, di_addr * sdp->bsize) != sdp->bsize) {
+ if (pread(sdp->device_fd, bh->b_data, sdp->sd_bsize, di_addr * sdp->sd_bsize) != sdp->sd_bsize) {
brelse(bh);
return NULL;
}
diff --git a/gfs2/libgfs2/gfs2l.c b/gfs2/libgfs2/gfs2l.c
index e582a193..2872d70e 100644
--- a/gfs2/libgfs2/gfs2l.c
+++ b/gfs2/libgfs2/gfs2l.c
@@ -111,7 +111,7 @@ static int openfs(const char *path, struct gfs2_sbd *sdp)
}
memset(sdp, 0, sizeof(*sdp));
- sdp->bsize = GFS2_BASIC_BLOCK;
+ sdp->sd_bsize = GFS2_BASIC_BLOCK;
sdp->device_fd = fd;
ret = compute_constants(sdp);
if (ret != 0) {
@@ -131,7 +131,7 @@ static int openfs(const char *path, struct gfs2_sbd *sdp)
return 1;
}
- sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
gfs2_lookupi(sdp->master_dir, "rindex", 6, &sdp->md.riinode);
sdp->fssize = sdp->device.length;
if (sdp->md.riinode) {
diff --git a/gfs2/libgfs2/lang.c b/gfs2/libgfs2/lang.c
index 3387df57..3633c7a7 100644
--- a/gfs2/libgfs2/lang.c
+++ b/gfs2/libgfs2/lang.c
@@ -158,7 +158,7 @@ static uint64_t ast_lookup_path(char *path, struct gfs2_sbd *sbd)
uint64_t bn = 0;
segment = strtok_r(path, "/", &c);
- ip = lgfs2_inode_read(sbd, sbd->sd_sb.sb_root_dir.no_addr);
+ ip = lgfs2_inode_read(sbd, sbd->sd_root_dir.no_addr);
while (ip != NULL) {
if (segment == NULL) { // No more segments
@@ -215,10 +215,10 @@ static uint64_t ast_lookup_id(const char *id, struct gfs2_sbd *sbd)
bn = LGFS2_SB_ADDR(sbd);
break;
case ID_MASTER:
- bn = sbd->sd_sb.sb_master_dir.no_addr;
+ bn = sbd->sd_meta_dir.no_addr;
break;
case ID_ROOT:
- bn = sbd->sd_sb.sb_root_dir.no_addr;
+ bn = sbd->sd_root_dir.no_addr;
break;
case ID_RINDEX:
bn = sbd->md.riinode->i_addr;
@@ -438,7 +438,7 @@ static struct lgfs2_lang_result *ast_interp_get(struct lgfs2_lang_state *state,
free(result);
return NULL;
}
- result->lr_buf = lang_read_block(sbd->device_fd, sbd->bsize, result->lr_blocknr);
+ result->lr_buf = lang_read_block(sbd->device_fd, sbd->sd_bsize, result->lr_blocknr);
if (result->lr_buf == NULL) {
free(result);
return NULL;
@@ -539,7 +539,7 @@ static struct lgfs2_lang_result *ast_interp_set(struct lgfs2_lang_state *state,
result->lr_blocknr = ast_lookup_block(lookup, sbd);
if (result->lr_blocknr == 0)
goto out_err;
- result->lr_buf = lang_read_block(sbd->device_fd, sbd->bsize, result->lr_blocknr);
+ result->lr_buf = lang_read_block(sbd->device_fd, sbd->sd_bsize, result->lr_blocknr);
if (result->lr_buf == NULL)
goto out_err;
@@ -580,7 +580,7 @@ static struct lgfs2_lang_result *ast_interp_set(struct lgfs2_lang_state *state,
}
}
- ret = lang_write_result(sbd->device_fd, sbd->bsize, result);
+ ret = lang_write_result(sbd->device_fd, sbd->sd_bsize, result);
if (ret != 0)
goto out_err;
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index f3d4ee78..49250fab 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -302,12 +302,25 @@ struct master_dir
#define LGFS2_SB_ADDR(sdp) (GFS2_SB_ADDR >> (sdp)->sd_fsb2bb_shift)
struct gfs2_sbd {
- struct gfs2_sb sd_sb; /* a copy of the ondisk structure */
-
- unsigned int bsize; /* The block size of the FS (in bytes) */
- unsigned int jsize; /* Size of journals (in MB) */
- unsigned int rgsize; /* Size of resource groups (in MB) */
- unsigned int qcsize; /* Size of quota change files (in MB) */
+ /* CPU-endian counterparts to the on-disk superblock fields */
+ uint32_t sd_bsize;
+ uint32_t sd_fs_format;
+ uint32_t sd_multihost_format;
+ uint32_t sd_flags; /* gfs1 */
+ struct {
+ uint64_t no_formal_ino;
+ uint64_t no_addr;
+ } sd_meta_dir,
+ sd_root_dir,
+ sd_rindex_di, /* gfs1 */
+ sd_jindex_di, /* gfs1 */
+ sd_quota_di, /* gfs1 */
+ sd_license_di; /* gfs1 */
+ uint32_t sd_bsize_shift;
+ uint32_t sd_seg_size;
+ char sd_lockproto[GFS2_LOCKNAME_LEN];
+ char sd_locktable[GFS2_LOCKNAME_LEN];
+ uint8_t sd_uuid[16];
/* Constants */
@@ -326,7 +339,9 @@ struct gfs2_sbd {
uint64_t sd_heightsize[GFS2_MAX_META_HEIGHT];
uint64_t sd_jheightsize[GFS2_MAX_META_HEIGHT];
- /* Not specified on the command line, but... */
+ unsigned int jsize; /* Size of journals (in MB) */
+ unsigned int rgsize; /* Size of resource groups (in MB) */
+ unsigned int qcsize; /* Size of quota change files (in MB) */
int64_t time;
@@ -731,8 +746,7 @@ static inline unsigned int rgrp_size(struct rgrp_tree *rgrp)
/* structures.c */
extern int build_master(struct gfs2_sbd *sdp);
-extern void lgfs2_sb_init(struct gfs2_sb *sb, unsigned bsize, unsigned format);
-extern int lgfs2_sb_write(const struct gfs2_sb *sb, int fd, const unsigned bsize);
+extern int lgfs2_sb_write(const struct gfs2_sbd *sdp, int fd);
extern int build_journal(struct gfs2_sbd *sdp, int j,
struct gfs2_inode *jindex);
extern int build_jindex(struct gfs2_sbd *sdp);
@@ -753,7 +767,7 @@ extern int build_statfs_change(struct gfs2_inode *per_node, unsigned int j);
extern int build_quota_change(struct gfs2_inode *per_node, unsigned int j);
/* super.c */
-extern int check_sb(struct gfs2_sb *sb);
+extern int check_sb(void *sbp);
extern int read_sb(struct gfs2_sbd *sdp);
extern int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount, int *ok);
extern int write_sb(struct gfs2_sbd *sdp);
@@ -769,8 +783,8 @@ extern void gfs2_inum_in(struct gfs2_inum *no, char *buf);
extern void gfs2_inum_out(const struct gfs2_inum *no, char *buf);
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 lgfs2_sb_in(struct gfs2_sbd *sdp, void *buf);
+extern void lgfs2_sb_out(const struct gfs2_sbd *sdp, void *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);
diff --git a/gfs2/libgfs2/misc.c b/gfs2/libgfs2/misc.c
index 6dfd9afb..f2bab8ef 100644
--- a/gfs2/libgfs2/misc.c
+++ b/gfs2/libgfs2/misc.c
@@ -43,19 +43,19 @@ int compute_constants(struct gfs2_sbd *sdp)
sdp->md.next_inum = 1;
- sdp->sd_sb.sb_bsize_shift = ffs(sdp->bsize) - 1;
- sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
+ sdp->sd_bsize_shift = ffs(sdp->sd_bsize) - 1;
+ sdp->sd_fsb2bb_shift = sdp->sd_bsize_shift -
GFS2_BASIC_BLOCK_SHIFT;
sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
- sdp->sd_diptrs = (sdp->bsize - sizeof(struct gfs2_dinode)) /
+ sdp->sd_diptrs = (sdp->sd_bsize - sizeof(struct gfs2_dinode)) /
sizeof(uint64_t);
- sdp->sd_inptrs = (sdp->bsize - sizeof(struct gfs2_meta_header)) /
+ sdp->sd_inptrs = (sdp->sd_bsize - sizeof(struct gfs2_meta_header)) /
sizeof(uint64_t);
- sdp->sd_jbsize = sdp->bsize - sizeof(struct gfs2_meta_header);
- sdp->sd_hash_bsize = sdp->bsize / 2;
- sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
+ sdp->sd_jbsize = sdp->sd_bsize - sizeof(struct gfs2_meta_header);
+ sdp->sd_hash_bsize = sdp->sd_bsize / 2;
+ sdp->sd_hash_bsize_shift = sdp->sd_bsize_shift - 1;
sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(uint64_t);
- sdp->sd_blocks_per_bitmap = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header))
+ sdp->sd_blocks_per_bitmap = (sdp->sd_bsize - sizeof(struct gfs2_meta_header))
* GFS2_NBBY;
/* Compute maximum reservation required to add a entry to a directory */
@@ -73,11 +73,11 @@ int compute_constants(struct gfs2_sbd *sdp)
sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;
- if (compute_heightsize(sdp->bsize, sdp->sd_heightsize, &sdp->sd_max_height,
- sdp->bsize, sdp->sd_diptrs, sdp->sd_inptrs)) {
+ if (compute_heightsize(sdp->sd_bsize, sdp->sd_heightsize, &sdp->sd_max_height,
+ sdp->sd_bsize, sdp->sd_diptrs, sdp->sd_inptrs)) {
return -1;
}
- if (compute_heightsize(sdp->bsize, sdp->sd_jheightsize, &sdp->sd_max_jheight,
+ if (compute_heightsize(sdp->sd_bsize, sdp->sd_jheightsize, &sdp->sd_max_jheight,
sdp->sd_jbsize, sdp->sd_diptrs, sdp->sd_inptrs)) {
return -1;
}
diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c
index 3fe8aa0a..a1805234 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -117,54 +117,57 @@ void lgfs2_meta_header_print(void *mhp)
printbe32(mh, mh_format);
}
-void gfs2_sb_in(struct gfs2_sb *sb, char *buf)
+void lgfs2_sb_in(struct gfs2_sbd *sdp, void *buf)
{
- struct gfs2_sb *str = (struct gfs2_sb *)buf;
-
- gfs2_meta_header_in(&sb->sb_header, buf);
-
- CPIN_32(sb, str, sb_fs_format);
- CPIN_32(sb, str, sb_multihost_format);
- CPIN_32(sb, str, __pad0); /* gfs sb_flags */
-
- CPIN_32(sb, str, sb_bsize);
- CPIN_32(sb, str, sb_bsize_shift);
- CPIN_32(sb, str, __pad1); /* gfs sb_seg_size */
-
- gfs2_inum_in(&sb->sb_master_dir, (char *)&str->sb_master_dir);
- gfs2_inum_in(&sb->sb_root_dir, (char *)&str->sb_root_dir);
-
- CPIN_08(sb, str, sb_lockproto, GFS2_LOCKNAME_LEN);
- CPIN_08(sb, str, sb_locktable, GFS2_LOCKNAME_LEN);
- gfs2_inum_in(&sb->__pad2, (char *)&str->__pad2); /* gfs rindex */
- gfs2_inum_in(&sb->__pad3, (char *)&str->__pad3); /* gfs quota */
- gfs2_inum_in(&sb->__pad4, (char *)&str->__pad4); /* gfs license */
- CPIN_08(sb, str, sb_uuid, sizeof(sb->sb_uuid));
+ struct gfs2_sb *sb = buf;
+
+ sdp->sd_fs_format = be32_to_cpu(sb->sb_fs_format);
+ sdp->sd_multihost_format = be32_to_cpu(sb->sb_multihost_format);
+ sdp->sd_flags = be32_to_cpu(sb->__pad0);
+ sdp->sd_bsize = be32_to_cpu(sb->sb_bsize);
+ sdp->sd_bsize_shift = be32_to_cpu(sb->sb_bsize_shift);
+ sdp->sd_seg_size = be32_to_cpu(sb->__pad1);
+ sdp->sd_meta_dir.no_formal_ino = be64_to_cpu(sb->sb_master_dir.no_formal_ino);
+ sdp->sd_meta_dir.no_addr = be64_to_cpu(sb->sb_master_dir.no_addr);
+ sdp->sd_root_dir.no_formal_ino = be64_to_cpu(sb->sb_root_dir.no_formal_ino);
+ sdp->sd_root_dir.no_addr = be64_to_cpu(sb->sb_root_dir.no_addr);
+ memcpy(sdp->sd_lockproto, sb->sb_lockproto, GFS2_LOCKNAME_LEN);
+ memcpy(sdp->sd_locktable, sb->sb_locktable, GFS2_LOCKNAME_LEN);
+ sdp->sd_rindex_di.no_formal_ino = be64_to_cpu(sb->__pad2.no_formal_ino);
+ sdp->sd_rindex_di.no_addr = be64_to_cpu(sb->__pad2.no_addr);
+ sdp->sd_quota_di.no_formal_ino = be64_to_cpu(sb->__pad3.no_formal_ino);
+ sdp->sd_quota_di.no_addr = be64_to_cpu(sb->__pad3.no_addr);
+ sdp->sd_license_di.no_formal_ino = be64_to_cpu(sb->__pad4.no_formal_ino);
+ sdp->sd_license_di.no_addr = be64_to_cpu(sb->__pad4.no_addr);
+ memcpy(sdp->sd_uuid, sb->sb_uuid, sizeof(sdp->sd_uuid));
}
-void gfs2_sb_out(const struct gfs2_sb *sb, char *buf)
+void lgfs2_sb_out(const struct gfs2_sbd *sdp, void *buf)
{
- struct gfs2_sb *str = (struct gfs2_sb *)buf;
-
- gfs2_meta_header_out(&sb->sb_header, buf);
-
- CPOUT_32(sb, str, sb_fs_format);
- CPOUT_32(sb, str, sb_multihost_format);
- CPOUT_32(sb, str, __pad0); /* gfs sb_flags */
-
- CPOUT_32(sb, str, sb_bsize);
- CPOUT_32(sb, str, sb_bsize_shift);
- CPOUT_32(sb, str, __pad1); /* gfs sb_seg_size */
-
- gfs2_inum_out(&sb->sb_master_dir, (char *)&str->sb_master_dir);
- gfs2_inum_out(&sb->sb_root_dir, (char *)&str->sb_root_dir);
-
- CPOUT_08(sb, str, sb_lockproto, GFS2_LOCKNAME_LEN);
- CPOUT_08(sb, str, sb_locktable, GFS2_LOCKNAME_LEN);
- gfs2_inum_out(&sb->__pad2, (char *)&str->__pad2); /* gfs rindex */
- gfs2_inum_out(&sb->__pad3, (char *)&str->__pad3); /* gfs quota */
- gfs2_inum_out(&sb->__pad4, (char *)&str->__pad4); /* gfs license */
- memcpy(str->sb_uuid, sb->sb_uuid, 16);
+ struct gfs2_sb *sb = buf;
+
+ sb->sb_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
+ sb->sb_header.mh_type = cpu_to_be32(GFS2_METATYPE_SB);
+ sb->sb_header.mh_format = cpu_to_be32(GFS2_FORMAT_SB);
+ sb->sb_fs_format = cpu_to_be32(sdp->sd_fs_format);
+ sb->sb_multihost_format = cpu_to_be32(sdp->sd_multihost_format);
+ sb->__pad0 = cpu_to_be32(sdp->sd_flags);
+ sb->sb_bsize = cpu_to_be32(sdp->sd_bsize);
+ sb->sb_bsize_shift = cpu_to_be32(sdp->sd_bsize_shift);
+ sb->__pad1 = cpu_to_be32(sdp->sd_seg_size);
+ sb->sb_master_dir.no_formal_ino = cpu_to_be64(sdp->sd_meta_dir.no_formal_ino);
+ sb->sb_master_dir.no_addr = cpu_to_be64(sdp->sd_meta_dir.no_addr);
+ sb->sb_root_dir.no_formal_ino = cpu_to_be64(sdp->sd_root_dir.no_formal_ino);
+ sb->sb_root_dir.no_addr = cpu_to_be64(sdp->sd_root_dir.no_addr);
+ memcpy(sb->sb_lockproto, sdp->sd_lockproto, GFS2_LOCKNAME_LEN);
+ memcpy(sb->sb_locktable, sdp->sd_locktable, GFS2_LOCKNAME_LEN);
+ sb->__pad2.no_formal_ino = cpu_to_be64(sdp->sd_rindex_di.no_formal_ino);
+ sb->__pad2.no_addr = cpu_to_be64(sdp->sd_rindex_di.no_addr);
+ sb->__pad3.no_formal_ino = cpu_to_be64(sdp->sd_quota_di.no_formal_ino);
+ sb->__pad3.no_addr = cpu_to_be64(sdp->sd_quota_di.no_addr);
+ sb->__pad4.no_formal_ino = cpu_to_be64(sdp->sd_license_di.no_formal_ino);
+ sb->__pad4.no_addr = cpu_to_be64(sdp->sd_license_di.no_addr);
+ memcpy(sb->sb_uuid, sdp->sd_uuid, 16);
}
void lgfs2_sb_print(void *sbp)
diff --git a/gfs2/libgfs2/recovery.c b/gfs2/libgfs2/recovery.c
index 7c445f15..9234a867 100644
--- a/gfs2/libgfs2/recovery.c
+++ b/gfs2/libgfs2/recovery.c
@@ -16,7 +16,7 @@
void gfs2_replay_incr_blk(struct gfs2_inode *ip, unsigned int *blk)
{
- uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_bsize;
if (++*blk == jd_blocks)
*blk = 0;
@@ -85,7 +85,7 @@ int lgfs2_get_log_header(struct gfs2_inode *ip, unsigned int blk,
tmp->lh_hash = 0;
hash = lgfs2_log_header_hash(bh->b_data);
tmp->lh_hash = saved_hash;
- crc = lgfs2_log_header_crc(bh->b_data, ip->i_sbd->bsize);
+ crc = lgfs2_log_header_crc(bh->b_data, ip->i_sbd->sd_bsize);
log_header_in(&lh, bh->b_data);
brelse(bh);
lh_crc = lh.lh_crc;
@@ -116,7 +116,7 @@ static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk, struct lgfs2_l
{
unsigned int orig_blk = *blk;
int error;
- uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_bsize;
for (;;) {
error = lgfs2_get_log_header(ip, *blk, head);
@@ -145,7 +145,7 @@ static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk, struct lgfs2_l
static int jhead_scan(struct gfs2_inode *ip, struct lgfs2_log_header *head)
{
unsigned int blk = head->lh_blkno;
- uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_bsize;
struct lgfs2_log_header lh;
int error;
@@ -185,7 +185,7 @@ int lgfs2_find_jhead(struct gfs2_inode *ip, struct lgfs2_log_header *head)
{
struct lgfs2_log_header lh_1, lh_m;
uint32_t blk_1, blk_2, blk_m;
- uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_bsize;
int error;
blk_1 = 0;
@@ -245,7 +245,7 @@ int lgfs2_clean_journal(struct gfs2_inode *ip, struct lgfs2_log_header *head)
return -EIO;
bh = bread(ip->i_sbd, dblock);
- memset(bh->b_data, 0, ip->i_sbd->bsize);
+ memset(bh->b_data, 0, ip->i_sbd->sd_bsize);
lh = (struct gfs2_log_header *)bh->b_data;
memset(lh, 0, sizeof(struct gfs2_log_header));
diff --git a/gfs2/libgfs2/rgrp.c b/gfs2/libgfs2/rgrp.c
index 96789ff4..454f6e60 100644
--- a/gfs2/libgfs2/rgrp.c
+++ b/gfs2/libgfs2/rgrp.c
@@ -109,14 +109,14 @@ 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->rt_length * sdp->bsize;
- unsigned long io_align = sdp->bsize;
+ size_t len = rg->rt_length * sdp->sd_bsize;
+ unsigned long io_align = sdp->sd_bsize;
unsigned i;
char *bufs;
if (rg->rgrps->align > 0) {
- len = ROUND_UP(len, rg->rgrps->align * sdp->bsize);
- io_align = rg->rgrps->align_off * sdp->bsize;
+ len = ROUND_UP(len, rg->rgrps->align * sdp->sd_bsize);
+ io_align = rg->rgrps->align_off * sdp->sd_bsize;
}
if (posix_memalign((void **)&bufs, io_align, len) != 0) {
errno = ENOMEM;
@@ -125,7 +125,7 @@ int lgfs2_rgrp_bitbuf_alloc(lgfs2_rgrp_t rg)
memset(bufs, 0, len);
for (i = 0; i < rg->rt_length; i++) {
- rg->bits[i].bi_data = bufs + (i * sdp->bsize);
+ rg->bits[i].bi_data = bufs + (i * sdp->sd_bsize);
rg->bits[i].bi_modified = 0;
}
return 0;
@@ -189,8 +189,8 @@ void lgfs2_rgrp_crc_set(char *buf)
*/
uint64_t gfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
{
- unsigned length = rgd->rt_length * sdp->bsize;
- off_t offset = rgd->rt_addr * sdp->bsize;
+ unsigned length = rgd->rt_length * sdp->sd_bsize;
+ off_t offset = rgd->rt_addr * sdp->sd_bsize;
char *buf;
if (length == 0 || gfs2_check_range(sdp, rgd->rt_addr))
@@ -208,7 +208,7 @@ uint64_t gfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
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);
+ rgd->bits[i].bi_data = buf + (i * sdp->sd_bsize);
if (gfs2_check_meta(rgd->bits[i].bi_data, mtype)) {
free(buf);
rgd->bits[0].bi_data = NULL;
@@ -232,14 +232,14 @@ void gfs2_rgrp_relse(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
if (rgd->bits == NULL)
return;
for (unsigned i = 0; i < rgd->rt_length; i++) {
- off_t offset = sdp->bsize * (rgd->rt_addr + i);
+ off_t offset = sdp->sd_bsize * (rgd->rt_addr + i);
ssize_t ret;
if (rgd->bits[i].bi_data == NULL || !rgd->bits[i].bi_modified)
continue;
- ret = pwrite(sdp->device_fd, rgd->bits[i].bi_data, sdp->bsize, offset);
- if (ret != sdp->bsize) {
+ ret = pwrite(sdp->device_fd, rgd->bits[i].bi_data, sdp->sd_bsize, offset);
+ if (ret != sdp->sd_bsize) {
fprintf(stderr, "Failed to write modified resource group at block %"PRIu64": %s\n",
rgd->rt_addr, strerror(errno));
}
@@ -344,8 +344,8 @@ uint32_t lgfs2_rgrp_align_len(const lgfs2_rgrps_t rgs, uint32_t len)
*/
uint32_t lgfs2_rgrps_plan(const lgfs2_rgrps_t rgs, uint64_t space, uint32_t tgtsize)
{
- uint32_t maxlen = (GFS2_MAX_RGSIZE << 20) / rgs->sdp->bsize;
- uint32_t minlen = (GFS2_MIN_RGSIZE << 20) / rgs->sdp->bsize;
+ uint32_t maxlen = (GFS2_MAX_RGSIZE << 20) / rgs->sdp->sd_bsize;
+ uint32_t minlen = (GFS2_MIN_RGSIZE << 20) / rgs->sdp->sd_bsize;
struct rg_spec *spec = rgs->plan->rg_specs;
/* Apps should already have checked that the rg size is <=
@@ -579,7 +579,7 @@ uint64_t lgfs2_rindex_entry_new(lgfs2_rgrps_t rgs, struct gfs2_rindex *ri, uint6
if (addr + len > rgs->sdp->device.length)
return 0;
- ri_length = rgblocks2bitblocks(rgs->sdp->bsize, len, &ri_data);
+ ri_length = rgblocks2bitblocks(rgs->sdp->sd_bsize, len, &ri_data);
ri->ri_addr = cpu_to_be64(addr);
ri->ri_length = cpu_to_be32(ri_length);
ri->ri_data = cpu_to_be32(ri_data);
@@ -654,7 +654,7 @@ lgfs2_rgrp_t lgfs2_rgrps_append(lgfs2_rgrps_t rgs, struct gfs2_rindex *entry, ui
rg->rt_dinodes = 0;
rg->rt_skip = rg_skip;
rg->rt_igeneration = 0;
- compute_bitmaps(rg, rgs->sdp->bsize);
+ compute_bitmaps(rg, rgs->sdp->sd_bsize);
rg->rgrps = rgs;
return rg;
}
@@ -685,11 +685,11 @@ int lgfs2_rgrp_write(int fd, const lgfs2_rgrp_t rg)
mh->mh_format = cpu_to_be32(GFS2_FORMAT_RB);
}
- len = sdp->bsize * rg->rt_length;
+ len = sdp->sd_bsize * rg->rt_length;
if (rg->rgrps->align > 0)
- len = ROUND_UP(len, rg->rgrps->align * sdp->bsize);
+ len = ROUND_UP(len, rg->rgrps->align * sdp->sd_bsize);
- ret = pwrite(fd, rg->bits[0].bi_data, len, rg->rt_addr * sdp->bsize);
+ ret = pwrite(fd, rg->bits[0].bi_data, len, rg->rt_addr * sdp->sd_bsize);
if (freebufs)
lgfs2_rgrp_bitbuf_free(rg);
@@ -891,7 +891,7 @@ static uint32_t lgfs2_free_extlen(const struct lgfs2_rbm *rrbm, uint32_t len)
while (len > 3) {
bi = rbm_bi(&rbm);
start = (uint8_t *)bi->bi_data;
- end = start + sdp->bsize;
+ end = start + sdp->sd_bsize;
start += bi->bi_offset;
start += (rbm.offset / GFS2_NBBY);
bytes = (len / GFS2_NBBY) < (end - start) ? (len / GFS2_NBBY):(end - start);
diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c
index e900a7df..0957e5ad 100644
--- a/gfs2/libgfs2/structures.c
+++ b/gfs2/libgfs2/structures.c
@@ -46,31 +46,15 @@ int build_master(struct gfs2_sbd *sdp)
return 0;
}
-/**
- * Initialise a gfs2_sb structure with sensible defaults.
- */
-void lgfs2_sb_init(struct gfs2_sb *sb, unsigned bsize, unsigned format)
-{
- memset(sb, 0, sizeof(struct gfs2_sb));
- sb->sb_header.mh_magic = GFS2_MAGIC;
- sb->sb_header.mh_type = GFS2_METATYPE_SB;
- sb->sb_header.mh_format = GFS2_FORMAT_SB;
- sb->sb_fs_format = format;
- sb->sb_multihost_format = GFS2_FORMAT_MULTI;
- sb->sb_bsize = bsize;
- sb->sb_bsize_shift = ffs(bsize) - 1;
- uuid_generate(sb->sb_uuid);
-}
-
-int lgfs2_sb_write(const struct gfs2_sb *sb, int fd, const unsigned bsize)
+int lgfs2_sb_write(const struct gfs2_sbd *sdp, int fd)
{
int i, err = -1;
struct iovec *iov;
- const size_t sb_addr = GFS2_SB_ADDR * GFS2_BASIC_BLOCK / bsize;
+ const size_t sb_addr = GFS2_SB_ADDR * GFS2_BASIC_BLOCK / sdp->sd_bsize;
const size_t len = sb_addr + 1;
/* We only need 2 blocks: one for zeroing and a second for the superblock */
- char *buf = calloc(2, bsize);
+ char *buf = calloc(2, sdp->sd_bsize);
if (buf == NULL)
return -1;
@@ -80,13 +64,13 @@ int lgfs2_sb_write(const struct gfs2_sb *sb, int fd, const unsigned bsize)
for (i = 0; i < len; i++) {
iov[i].iov_base = buf;
- iov[i].iov_len = bsize;
+ iov[i].iov_len = sdp->sd_bsize;
}
- gfs2_sb_out(sb, buf + bsize);
- iov[sb_addr].iov_base = buf + bsize;
+ lgfs2_sb_out(sdp, buf + sdp->sd_bsize);
+ iov[sb_addr].iov_base = buf + sdp->sd_bsize;
- if (pwritev(fd, iov, len, 0) < (len * bsize))
+ if (pwritev(fd, iov, len, 0) < (len * sdp->sd_bsize))
goto out_iov;
err = 0;
@@ -125,14 +109,14 @@ uint32_t lgfs2_log_header_crc(char *buf, unsigned bsize)
int lgfs2_write_journal_data(struct gfs2_inode *ip)
{
struct gfs2_sbd *sdp = ip->i_sbd;
- unsigned blocks = (ip->i_size + sdp->bsize - 1) / sdp->bsize;
+ unsigned blocks = (ip->i_size + sdp->sd_bsize - 1) / sdp->sd_bsize;
uint64_t jext0 = ip->i_addr + ip->i_blocks - blocks;
uint64_t seq = ((blocks) * (random() / (RAND_MAX + 1.0)));
struct gfs2_log_header *lh;
uint64_t jblk = jext0;
char *buf;
- buf = calloc(1, sdp->bsize);
+ buf = calloc(1, sdp->sd_bsize);
if (buf == NULL)
return -1;
@@ -152,10 +136,10 @@ int lgfs2_write_journal_data(struct gfs2_inode *ip)
hash = lgfs2_log_header_hash(buf);
lh->lh_hash = cpu_to_be32(hash);
lh->lh_addr = cpu_to_be64(jblk);
- hash = lgfs2_log_header_crc(buf, sdp->bsize);
+ hash = lgfs2_log_header_crc(buf, sdp->sd_bsize);
lh->lh_crc = cpu_to_be32(hash);
- if (pwrite(sdp->device_fd, buf, sdp->bsize, jblk * sdp->bsize) != sdp->bsize) {
+ if (pwrite(sdp->device_fd, buf, sdp->sd_bsize, jblk * sdp->sd_bsize) != sdp->sd_bsize) {
free(buf);
return -1;
}
@@ -186,9 +170,9 @@ static struct gfs2_buffer_head *get_file_buf(struct gfs2_inode *ip, uint64_t lbn
return NULL;
if (!prealloc && new &&
- ip->i_size < (lbn + 1) << sdp->sd_sb.sb_bsize_shift) {
+ ip->i_size < (lbn + 1) << sdp->sd_bsize_shift) {
bmodified(ip->i_bh);
- ip->i_size = (lbn + 1) << sdp->sd_sb.sb_bsize_shift;
+ ip->i_size = (lbn + 1) << sdp->sd_bsize_shift;
}
if (dbn == ip->i_addr)
return ip->i_bh;
@@ -259,8 +243,8 @@ int build_journal(struct gfs2_sbd *sdp, int j, struct gfs2_inode *jindex)
if (sdp->md.journal[j] == NULL) {
return errno;
}
- ret = write_journal(sdp->md.journal[j], sdp->bsize,
- sdp->jsize << 20 >> sdp->sd_sb.sb_bsize_shift);
+ ret = write_journal(sdp->md.journal[j], sdp->sd_bsize,
+ sdp->jsize << 20 >> sdp->sd_bsize_shift);
return ret;
}
@@ -387,7 +371,7 @@ int build_quota_change(struct gfs2_inode *per_node, unsigned int j)
struct gfs2_meta_header mh;
char name[256];
struct gfs2_inode *ip;
- unsigned int blocks = sdp->qcsize << (20 - sdp->sd_sb.sb_bsize_shift);
+ unsigned int blocks = sdp->qcsize << (20 - sdp->sd_bsize_shift);
unsigned int x;
unsigned int hgt;
struct gfs2_buffer_head *bh;
@@ -403,7 +387,7 @@ int build_quota_change(struct gfs2_inode *per_node, unsigned int j)
return errno;
}
- hgt = calc_tree_height(ip, (blocks + 1) * sdp->bsize);
+ hgt = calc_tree_height(ip, (blocks + 1) * sdp->sd_bsize);
build_height(ip, hgt);
for (x = 0; x < blocks; x++) {
@@ -411,7 +395,7 @@ int build_quota_change(struct gfs2_inode *per_node, unsigned int j)
if (!bh)
return -1;
- memset(bh->b_data, 0, sdp->bsize);
+ memset(bh->b_data, 0, sdp->sd_bsize);
gfs2_meta_header_out(&mh, bh->b_data);
bmodified(bh);
brelse(bh);
diff --git a/gfs2/libgfs2/super.c b/gfs2/libgfs2/super.c
index f304b4df..cd2a2ecf 100644
--- a/gfs2/libgfs2/super.c
+++ b/gfs2/libgfs2/super.c
@@ -22,22 +22,24 @@
*
* Returns: -1 on failure, 1 if this is gfs (gfs1), 2 if this is gfs2
*/
-int check_sb(struct gfs2_sb *sb)
+int check_sb(void *sbp)
{
- if (sb->sb_header.mh_magic != GFS2_MAGIC ||
- sb->sb_header.mh_type != GFS2_METATYPE_SB) {
+ struct gfs2_sb *sb = sbp;
+
+ if (be32_to_cpu(sb->sb_header.mh_magic) != GFS2_MAGIC ||
+ be32_to_cpu(sb->sb_header.mh_type) != GFS2_METATYPE_SB) {
errno = EIO;
return -1;
}
/* Check for gfs1 */
- if (sb->sb_fs_format == GFS_FORMAT_FS &&
- sb->sb_header.mh_format == GFS_FORMAT_SB &&
- sb->sb_multihost_format == GFS_FORMAT_MULTI) {
+ if (be32_to_cpu(sb->sb_fs_format) == GFS_FORMAT_FS &&
+ be32_to_cpu(sb->sb_header.mh_format) == GFS_FORMAT_SB &&
+ be32_to_cpu(sb->sb_multihost_format) == GFS_FORMAT_MULTI) {
return 1;
}
/* It's gfs2. Check format number is in a sensible range. */
- if (sb->sb_fs_format < LGFS2_FS_FORMAT_MIN ||
- sb->sb_fs_format > 1899) {
+ if (be32_to_cpu(sb->sb_fs_format) < LGFS2_FS_FORMAT_MIN ||
+ be32_to_cpu(sb->sb_fs_format) > 1899) {
errno = EINVAL;
return -1;
}
@@ -64,40 +66,40 @@ int read_sb(struct gfs2_sbd *sdp)
int ret;
bh = bread(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
- gfs2_sb_in(&sdp->sd_sb, bh->b_data);
- brelse(bh);
- ret = check_sb(&sdp->sd_sb);
+ ret = check_sb(bh->b_data);
if (ret < 0)
return ret;
if (ret == 1)
sdp->gfs1 = 1;
- sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift - GFS2_BASIC_BLOCK_SHIFT;
- sdp->bsize = sdp->sd_sb.sb_bsize;
- if (sdp->bsize < 512 || sdp->bsize != (sdp->bsize & -sdp->bsize)) {
+
+ lgfs2_sb_in(sdp, bh->b_data);
+ brelse(bh);
+ sdp->sd_fsb2bb_shift = sdp->sd_bsize_shift - GFS2_BASIC_BLOCK_SHIFT;
+ if (sdp->sd_bsize < 512 || sdp->sd_bsize != (sdp->sd_bsize & -sdp->sd_bsize)) {
return -1;
}
if (sdp->gfs1) {
- sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
+ sdp->sd_diptrs = (sdp->sd_bsize -
sizeof(struct gfs_dinode)) /
sizeof(uint64_t);
- sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
+ sdp->sd_inptrs = (sdp->sd_bsize -
sizeof(struct gfs_indirect)) /
sizeof(uint64_t);
} else {
- sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
+ sdp->sd_diptrs = (sdp->sd_bsize -
sizeof(struct gfs2_dinode)) /
sizeof(uint64_t);
- sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
+ sdp->sd_inptrs = (sdp->sd_bsize -
sizeof(struct gfs2_meta_header)) /
sizeof(uint64_t);
}
- sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
- sdp->sd_hash_bsize = sdp->bsize / 2;
- sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
+ sdp->sd_jbsize = sdp->sd_bsize - sizeof(struct gfs2_meta_header);
+ sdp->sd_hash_bsize = sdp->sd_bsize / 2;
+ sdp->sd_hash_bsize_shift = sdp->sd_bsize_shift - 1;
sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(uint64_t);
- sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
- sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
+ sdp->sd_heightsize[0] = sdp->sd_bsize - sizeof(struct gfs2_dinode);
+ sdp->sd_heightsize[1] = sdp->sd_bsize * sdp->sd_diptrs;
for (x = 2; x < GFS2_MAX_META_HEIGHT; x++){
space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
/* FIXME: Do we really need this first check?? */
@@ -111,7 +113,7 @@ int read_sb(struct gfs2_sbd *sdp)
return -1;
}
- sdp->sd_jheightsize[0] = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
+ sdp->sd_jheightsize[0] = sdp->sd_bsize - sizeof(struct gfs2_dinode);
sdp->sd_jheightsize[1] = sdp->sd_jbsize * sdp->sd_diptrs;
for (x = 2; ; x++){
space = sdp->sd_jheightsize[x - 1] * sdp->sd_inptrs;
@@ -125,8 +127,8 @@ int read_sb(struct gfs2_sbd *sdp)
errno = E2BIG;
return -1;
}
- sdp->fssize = lseek(sdp->device_fd, 0, SEEK_END) / sdp->sd_sb.sb_bsize;
- sdp->sd_blocks_per_bitmap = (sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header))
+ sdp->fssize = lseek(sdp->device_fd, 0, SEEK_END) / sdp->sd_bsize;
+ sdp->sd_blocks_per_bitmap = (sdp->sd_bsize - sizeof(struct gfs2_meta_header))
* GFS2_NBBY;
sdp->qcsize = GFS2_DEFAULT_QCSIZE;
@@ -153,7 +155,7 @@ static int rgd_seems_ok(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
/* 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;
+ most_bitmaps_possible = (GFS2_MAX_RGSIZE * 1024 * 256) / sdp->sd_bsize;
if (rgd->rt_length > most_bitmaps_possible)
return 0;
@@ -247,7 +249,7 @@ int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount, int *ok)
prev_rgd->length = rgrp_size(prev_rgd);
}
- if(gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, rgd))
+ if(gfs2_compute_bitstructs(sdp->sd_bsize, rgd))
*ok = 0;
(*rgcount)++;
diff --git a/gfs2/mkfs/main_grow.c b/gfs2/mkfs/main_grow.c
index deb9230d..8204d263 100644
--- a/gfs2/mkfs/main_grow.c
+++ b/gfs2/mkfs/main_grow.c
@@ -174,8 +174,8 @@ static lgfs2_rgrps_t rgrps_init(struct gfs2_sbd *sdp)
if ((min_io_sz > phy_sector_sz) &&
(opt_io_sz > phy_sector_sz) &&
(opt_io_sz % min_io_sz == 0)) {
- al_base = opt_io_sz / sdp->bsize;
- al_off = min_io_sz / sdp->bsize;
+ al_base = opt_io_sz / sdp->sd_bsize;
+ al_off = min_io_sz / sdp->sd_bsize;
}
}
@@ -208,7 +208,7 @@ static unsigned initialize_new_portion(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs)
unsigned rgcount = 0;
uint64_t rgaddr = fssize;
- discard_blocks(sdp->device_fd, rgaddr * sdp->bsize, fsgrowth * sdp->bsize);
+ discard_blocks(sdp->device_fd, rgaddr * sdp->sd_bsize, fsgrowth * sdp->sd_bsize);
/* Build the remaining resource groups */
while (1) {
int err = 0;
@@ -332,7 +332,7 @@ static void print_info(struct gfs2_sbd *sdp, char *device, char *mnt_path)
(unsigned long long)sdp->device.length,
(unsigned long long)sdp->device.length);
log_notice(_("The file system will grow by %lluMB.\n"),
- (unsigned long long)(fsgrowth * sdp->bsize) / MB);
+ (unsigned long long)(fsgrowth * sdp->sd_bsize) / MB);
}
static int open_rindex(char *metafs_path, int mode)
@@ -366,7 +366,7 @@ int main(int argc, char *argv[])
srandom(time(NULL) ^ getpid());
memset(sdp, 0, sizeof(struct gfs2_sbd));
- sdp->bsize = GFS2_DEFAULT_BSIZE;
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
sdp->rgsize = -1;
sdp->jsize = GFS2_DEFAULT_JSIZE;
sdp->qcsize = GFS2_DEFAULT_QCSIZE;
@@ -395,8 +395,8 @@ int main(int argc, char *argv[])
perror(mnt->mnt_fsname);
exit(EXIT_FAILURE);
}
- sdp->sd_sb.sb_bsize = GFS2_DEFAULT_BSIZE;
- sdp->bsize = sdp->sd_sb.sb_bsize;
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
+ sdp->sd_bsize = sdp->sd_bsize;
if (compute_constants(sdp)) {
log_crit("%s\n", _("Failed to compute file system constants"));
exit(EXIT_FAILURE);
@@ -421,7 +421,7 @@ int main(int argc, char *argv[])
exit(EXIT_FAILURE);
}
/* Get master dinode */
- sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
if (sdp->master_dir == NULL) {
perror(_("Could not read master directory"));
exit(EXIT_FAILURE);
@@ -457,7 +457,7 @@ int main(int argc, char *argv[])
goto out;
}
fsgrowth = (sdp->device.length - fssize);
- rgcount = lgfs2_rgrps_plan(rgs, fsgrowth, ((GFS2_MAX_RGSIZE << 20) / sdp->bsize));
+ rgcount = lgfs2_rgrps_plan(rgs, fsgrowth, ((GFS2_MAX_RGSIZE << 20) / sdp->sd_bsize));
if (rgcount == 0) {
log_err( _("The calculated resource group size is too small.\n"));
log_err( _("%s has not grown.\n"), argv[optind]);
diff --git a/gfs2/mkfs/main_jadd.c b/gfs2/mkfs/main_jadd.c
index 8e349c9c..66d9e293 100644
--- a/gfs2/mkfs/main_jadd.c
+++ b/gfs2/mkfs/main_jadd.c
@@ -350,9 +350,9 @@ close_fd:
static int add_qc(struct gfs2_sbd *sdp, struct jadd_opts *opts)
{
int fd, error = 0;
- char new_name[256], buf[sdp->bsize];
+ char new_name[256], buf[sdp->sd_bsize];
unsigned int blocks =
- sdp->qcsize << (20 - sdp->sd_sb.sb_bsize_shift);
+ sdp->qcsize << (20 - sdp->sd_bsize_shift);
unsigned int x;
struct gfs2_meta_header mh;
@@ -362,9 +362,9 @@ static int add_qc(struct gfs2_sbd *sdp, struct jadd_opts *opts)
if ((error = set_flags(fd, JA_FL_CLEAR, FS_JOURNAL_DATA_FL)))
goto close_fd;
- memset(buf, 0, sdp->bsize);
+ memset(buf, 0, sdp->sd_bsize);
for (x=0; x<blocks; x++) {
- if (write(fd, buf, sdp->bsize) != sdp->bsize) {
+ if (write(fd, buf, sdp->sd_bsize) != sdp->sd_bsize) {
perror("add_qc write");
error = -1;
goto close_fd;
@@ -383,7 +383,7 @@ static int add_qc(struct gfs2_sbd *sdp, struct jadd_opts *opts)
gfs2_meta_header_out(&mh, buf);
for (x=0; x<blocks; x++) {
- if (write(fd, buf, sdp->bsize) != sdp->bsize) {
+ if (write(fd, buf, sdp->sd_bsize) != sdp->sd_bsize) {
perror("add_qc write");
error = 1;
goto close_fd;
@@ -413,7 +413,7 @@ static int gather_info(struct gfs2_sbd *sdp, struct jadd_opts *opts)
return -1;
}
- sdp->bsize = statbuf.f_bsize;
+ sdp->sd_bsize = statbuf.f_bsize;
sdp->blks_total = statbuf.f_blocks;
sdp->blks_alloced = sdp->blks_total - statbuf.f_bfree;
@@ -518,12 +518,12 @@ static int add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
{
int fd, error = 0;
char new_name[256], *buf;
- uint32_t x, blocks = sdp->jsize << (20 - sdp->sd_sb.sb_bsize_shift);
+ uint32_t x, blocks = sdp->jsize << (20 - sdp->sd_bsize_shift);
struct gfs2_log_header *lh;
uint64_t seq = RANDOM(blocks), addr = 0;
off_t off = 0;
- buf = calloc(1, sdp->bsize);
+ buf = calloc(1, sdp->sd_bsize);
if (buf == NULL)
return -1;
@@ -562,14 +562,14 @@ static int add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
lh->lh_blkno = cpu_to_be32(x);
hash = lgfs2_log_header_hash(buf);
lh->lh_hash = cpu_to_be32(hash);
- if (!(blk_addr = find_block_address(fd, off, sdp->bsize))) {
+ if (!(blk_addr = find_block_address(fd, off, sdp->sd_bsize))) {
error = -1;
goto close_fd;
}
lh->lh_addr = cpu_to_be64(blk_addr);
- hash = lgfs2_log_header_crc(buf, sdp->bsize);
+ hash = lgfs2_log_header_crc(buf, sdp->sd_bsize);
lh->lh_crc = cpu_to_be32(hash);
- if (write(fd, buf, sdp->bsize) != sdp->bsize) {
+ if (write(fd, buf, sdp->sd_bsize) != sdp->sd_bsize) {
perror("add_j write");
error = -1;
goto close_fd;
@@ -579,7 +579,7 @@ static int add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
if (++seq == blocks)
seq = 0;
- off += sdp->bsize;
+ off += sdp->sd_bsize;
}
error = fsync(fd);
@@ -610,8 +610,8 @@ static int check_fit(struct gfs2_sbd *sdp, struct jadd_opts *opts)
uint64_t blks_per_j, total_blks;
blks_per_j = 1 + 1 +
- lgfs2_space_for_data(sdp, sdp->bsize, sdp->qcsize << 20) +
- lgfs2_space_for_data(sdp, sdp->bsize, sdp->jsize << 20);
+ lgfs2_space_for_data(sdp, sdp->sd_bsize, sdp->qcsize << 20) +
+ lgfs2_space_for_data(sdp, sdp->sd_bsize, sdp->jsize << 20);
total_blks = opts->journals * blks_per_j;
if (total_blks > (sdp->blks_total - sdp->blks_alloced)) {
diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c
index 6374ebc7..bf9e0d6d 100644
--- a/gfs2/mkfs/main_mkfs.c
+++ b/gfs2/mkfs/main_mkfs.c
@@ -635,23 +635,23 @@ static int opts_check(struct mkfs_opts *opts)
return 0;
}
-static void print_results(struct gfs2_sb *sb, struct mkfs_opts *opts, uint64_t rgrps, uint64_t fssize)
+static void print_results(struct gfs2_sbd *sb, struct mkfs_opts *opts)
{
char readable_uuid[36+1];
- uuid_unparse(sb->sb_uuid, readable_uuid);
+ uuid_unparse(sb->sd_uuid, readable_uuid);
printf("%-27s%s\n", _("Device:"), opts->dev.path);
- printf("%-27s%u\n", _("Block size:"), sb->sb_bsize);
+ printf("%-27s%u\n", _("Block size:"), sb->sd_bsize);
printf("%-27s%.2f %s (%"PRIu64" %s)\n", _("Device size:"),
/* Translators: "GB" here means "gigabytes" */
(opts->dev.size / ((float)(1 << 30))), _("GB"),
- (opts->dev.size / sb->sb_bsize), _("blocks"));
+ (opts->dev.size / sb->sd_bsize), _("blocks"));
printf("%-27s%.2f %s (%"PRIu64" %s)\n", _("Filesystem size:"),
- (fssize / ((float)(1 << 30)) * sb->sb_bsize), _("GB"), fssize, _("blocks"));
+ (sb->fssize / ((float)(1 << 30)) * sb->sd_bsize), _("GB"), sb->fssize, _("blocks"));
printf("%-27s%u\n", _("Journals:"), opts->journals);
printf("%-27s%uMB\n", _("Journal size:"), opts->jsize);
- printf("%-27s%"PRIu64"\n", _("Resource groups:"), rgrps);
+ printf("%-27s%"PRIu64"\n", _("Resource groups:"), sb->rgrps);
printf("%-27s\"%s\"\n", _("Locking protocol:"), opts->lockproto);
printf("%-27s\"%s\"\n", _("Lock table:"), opts->locktable);
/* Translators: "UUID" = universally unique identifier. */
@@ -696,7 +696,7 @@ static int zero_gap(struct gfs2_sbd *sdp, uint64_t addr, size_t blocks)
perror(_("Failed to zero blocks\n"));
return 1;
}
- zerobuf = calloc(1, sdp->bsize);
+ zerobuf = calloc(1, sdp->sd_bsize);
if (zerobuf == NULL) {
perror(_("Failed to zero blocks\n"));
free(iov);
@@ -704,10 +704,10 @@ static int zero_gap(struct gfs2_sbd *sdp, uint64_t addr, size_t blocks)
}
for (i = 0; i < blocks; i++) {
iov[i].iov_base = zerobuf;
- iov[i].iov_len = sdp->bsize;
+ iov[i].iov_len = sdp->sd_bsize;
}
- wrote = pwritev(sdp->device_fd, iov, blocks, addr * sdp->bsize);
- if (wrote != blocks * sdp->bsize) {
+ wrote = pwritev(sdp->device_fd, iov, blocks, addr * sdp->sd_bsize);
+ if (wrote != blocks * sdp->sd_bsize) {
fprintf(stderr, _("Zeroing write failed at block %"PRIu64"\n"), addr);
free(zerobuf);
free(iov);
@@ -725,17 +725,17 @@ static lgfs2_rgrps_t rgs_init(struct mkfs_opts *opts, struct gfs2_sbd *sdp)
uint64_t al_off = 0;
if (opts->align && opts->got_sunit) {
- if ((opts->sunit % sdp->bsize) != 0) {
+ if ((opts->sunit % sdp->sd_bsize) != 0) {
fprintf(stderr, _("Stripe unit (%lu) must be a multiple of block size (%u)\n"),
- opts->sunit, sdp->bsize);
+ opts->sunit, sdp->sd_bsize);
return NULL;
} else if ((opts->swidth % opts->sunit) != 0) {
fprintf(stderr, _("Stripe width (%lu) must be a multiple of stripe unit (%lu)\n"),
opts->swidth, opts->sunit);
return NULL;
} else {
- al_base = opts->swidth / sdp->bsize;
- al_off = opts->sunit / sdp->bsize;
+ al_base = opts->swidth / sdp->sd_bsize;
+ al_off = opts->sunit / sdp->sd_bsize;
}
} else if (opts->align) {
if (opts->dev.optimal_io_size <= opts->dev.physical_sector_size ||
@@ -746,8 +746,8 @@ static lgfs2_rgrps_t rgs_init(struct mkfs_opts *opts, struct gfs2_sbd *sdp)
rgrp alignment */
opts->align = 0;
} else {
- al_base = opts->dev.optimal_io_size / sdp->bsize;
- al_off = opts->dev.minimum_io_size / sdp->bsize;
+ al_base = opts->dev.optimal_io_size / sdp->sd_bsize;
+ al_off = opts->dev.minimum_io_size / sdp->sd_bsize;
}
}
@@ -770,7 +770,7 @@ 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;
+ uint64_t prev_end = (GFS2_SB_ADDR * GFS2_BASIC_BLOCK / sdp->sd_bsize) + 1;
lgfs2_rgrp_t prev = lgfs2_rgrp_prev(rg);
struct gfs2_rindex ri;
uint64_t addr;
@@ -837,8 +837,8 @@ static int add_rgrp(lgfs2_rgrps_t rgs, uint64_t *addr, uint32_t len, lgfs2_rgrp_
static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, struct mkfs_opts *opts, uint64_t *rgaddr)
{
struct gfs2_progress_bar progress;
- uint64_t jfsize = lgfs2_space_for_data(sdp, sdp->bsize, opts->jsize << 20);
- uint32_t rgsize = lgfs2_rgsize_for_data(jfsize, sdp->bsize);
+ uint64_t jfsize = lgfs2_space_for_data(sdp, sdp->sd_bsize, opts->jsize << 20);
+ uint32_t rgsize = lgfs2_rgsize_for_data(jfsize, sdp->sd_bsize);
unsigned j;
gfs2_progress_init(&progress, opts->journals, _("Adding journals: "), opts->quiet);
@@ -912,7 +912,7 @@ static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, struct mkfs_o
static int place_rgrps(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, uint64_t *rgaddr, struct mkfs_opts *opts)
{
struct gfs2_progress_bar progress;
- uint32_t rgblks = ((opts->rgsize << 20) / sdp->bsize);
+ uint32_t rgblks = ((opts->rgsize << 20) / sdp->sd_bsize);
uint32_t rgnum;
int result;
@@ -983,19 +983,24 @@ static int sbd_init(struct gfs2_sbd *sdp, struct mkfs_opts *opts, unsigned bsize
sdp->jsize = opts->jsize;
sdp->md.journals = opts->journals;
sdp->device_fd = opts->dev.fd;
- sdp->bsize = sdp->sd_sb.sb_bsize = bsize;
+ sdp->sd_bsize = bsize;
+ sdp->sd_fs_format = opts->format;
+ sdp->sd_multihost_format = GFS2_FORMAT_MULTI;
+ sdp->sd_bsize = bsize;
+ sdp->sd_bsize_shift = ffs(bsize) - 1;
+ uuid_generate(sdp->sd_uuid);
if (compute_constants(sdp)) {
perror(_("Failed to compute file system constants"));
return -1;
}
- sdp->device.length = opts->dev.size / sdp->bsize;
+ sdp->device.length = opts->dev.size / sdp->sd_bsize;
if (opts->got_fssize) {
if (opts->fssize > sdp->device.length) {
fprintf(stderr, _("Specified size is bigger than the device."));
fprintf(stderr, "%s %.2f %s (%"PRIu64" %s)\n", _("Device size:"),
opts->dev.size / ((float)(1 << 30)), _("GB"),
- opts->dev.size / sdp->bsize, _("blocks"));
+ opts->dev.size / sdp->sd_bsize, _("blocks"));
return -1;
}
sdp->device.length = opts->fssize;
@@ -1004,20 +1009,20 @@ static int sbd_init(struct gfs2_sbd *sdp, struct mkfs_opts *opts, unsigned bsize
makes sense for the device size, or set a sensible default, if one
will fit. For user-provided journal sizes, limit it to half of the fs. */
if (!opts->got_jsize) {
- int default_jsize = default_journal_size(sdp->bsize, sdp->device.length / opts->journals);
+ int default_jsize = default_journal_size(sdp->sd_bsize, sdp->device.length / opts->journals);
unsigned jsize_mb;
if (default_jsize < 0) {
fprintf(stderr, _("gfs2 will not fit on this device.\n"));
return -1;
}
- jsize_mb = (default_jsize * sdp->bsize) >> 20;
+ jsize_mb = (default_jsize * sdp->sd_bsize) >> 20;
if (jsize_mb < GFS2_MIN_JSIZE)
opts->jsize = GFS2_MIN_JSIZE;
else
opts->jsize = jsize_mb;
- } else if ((((opts->jsize * opts->journals) << 20) / sdp->bsize) > (sdp->device.length / 2)) {
- unsigned max_jsize = (sdp->device.length / 2 * sdp->bsize / opts->journals) >> 20;
+ } else if ((((opts->jsize * opts->journals) << 20) / sdp->sd_bsize) > (sdp->device.length / 2)) {
+ unsigned max_jsize = (sdp->device.length / 2 * sdp->sd_bsize / opts->journals) >> 20;
fprintf(stderr, _("gfs2 will not fit on this device.\n"));
if (max_jsize >= GFS2_MIN_JSIZE)
@@ -1118,7 +1123,6 @@ static int open_dev(struct mkfs_dev *dev, int withprobe)
int main(int argc, char *argv[])
{
struct gfs2_sbd sbd;
- struct gfs2_sb sb;
struct mkfs_opts opts;
lgfs2_rgrps_t rgs;
uint64_t rgaddr;
@@ -1149,13 +1153,11 @@ int main(int argc, char *argv[])
if (S_ISREG(opts.dev.stat.st_mode)) {
opts.got_bsize = 1; /* Use default block size for regular files */
}
-
if (sbd_init(&sbd, &opts, bsize) != 0)
exit(-1);
- lgfs2_sb_init(&sb, bsize, opts.format);
if (opts.debug) {
printf(_("File system options:\n"));
- printf(" bsize = %u\n", sbd.bsize);
+ printf(" bsize = %u\n", sbd.sd_bsize);
printf(" qcsize = %u\n", sbd.qcsize);
printf(" jsize = %u\n", sbd.jsize);
printf(" journals = %u\n", sbd.md.journals);
@@ -1205,8 +1207,8 @@ int main(int argc, char *argv[])
fprintf(stderr, _("Error building '%s': %s\n"), "master", strerror(errno));
exit(EXIT_FAILURE);
}
- sb.sb_master_dir.no_addr = sbd.master_dir->i_addr;
- sb.sb_master_dir.no_formal_ino = sbd.master_dir->i_formal_ino;
+ sbd.sd_meta_dir.no_addr = sbd.master_dir->i_addr;
+ sbd.sd_meta_dir.no_formal_ino = sbd.master_dir->i_formal_ino;
error = lgfs2_build_jindex(sbd.master_dir, mkfs_journals, opts.journals);
if (error) {
@@ -1249,13 +1251,13 @@ int main(int argc, char *argv[])
printf("%s", _("Done\n"));
build_root(&sbd);
- sb.sb_root_dir.no_addr = sbd.md.rooti->i_addr;
- sb.sb_root_dir.no_formal_ino = sbd.md.rooti->i_formal_ino;
+ sbd.sd_root_dir.no_addr = sbd.md.rooti->i_addr;
+ sbd.sd_root_dir.no_formal_ino = sbd.md.rooti->i_formal_ino;
- strncpy(sb.sb_lockproto, opts.lockproto, GFS2_LOCKNAME_LEN - 1);
- strncpy(sb.sb_locktable, opts.locktable, GFS2_LOCKNAME_LEN - 1);
- sb.sb_lockproto[GFS2_LOCKNAME_LEN - 1] = '\0';
- sb.sb_locktable[GFS2_LOCKNAME_LEN - 1] = '\0';
+ strncpy(sbd.sd_lockproto, opts.lockproto, GFS2_LOCKNAME_LEN - 1);
+ strncpy(sbd.sd_locktable, opts.locktable, GFS2_LOCKNAME_LEN - 1);
+ sbd.sd_lockproto[GFS2_LOCKNAME_LEN - 1] = '\0';
+ sbd.sd_locktable[GFS2_LOCKNAME_LEN - 1] = '\0';
do_init_inum(&sbd);
do_init_statfs(&sbd);
@@ -1272,7 +1274,7 @@ int main(int argc, char *argv[])
fflush(stdout);
}
- error = lgfs2_sb_write(&sb, opts.dev.fd, sbd.bsize);
+ error = lgfs2_sb_write(&sbd, opts.dev.fd);
if (error) {
perror(_("Failed to write superblock\n"));
exit(EXIT_FAILURE);
@@ -1291,7 +1293,7 @@ int main(int argc, char *argv[])
if (!opts.quiet) {
printf("%s", _("Done\n"));
- print_results(&sb, &opts, sbd.rgrps, sbd.fssize);
+ print_results(&sbd, &opts);
}
return 0;
}
diff --git a/tests/nukerg.c b/tests/nukerg.c
index 3bca919c..b5ddeb0b 100644
--- a/tests/nukerg.c
+++ b/tests/nukerg.c
@@ -192,7 +192,7 @@ static int nuke_rgs(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, unsigned *rgnums, s
lgfs2_rindex_out(rg, &ri);
for (j = 0; j < count; j++) {
uint64_t addr = be64_to_cpu(ri.ri_addr);
- off_t off = addr * sdp->bsize;
+ off_t off = addr * sdp->sd_bsize;
ssize_t bytes;
if (i != rgnums[j] && rgnums[j] != ALL_RGS)
@@ -278,8 +278,7 @@ static lgfs2_rgrps_t read_rindex(struct gfs2_sbd *sdp)
static int fill_super_block(struct gfs2_sbd *sdp)
{
- sdp->sd_sb.sb_bsize = GFS2_BASIC_BLOCK;
- sdp->bsize = sdp->sd_sb.sb_bsize;
+ sdp->sd_bsize = GFS2_BASIC_BLOCK;
if (compute_constants(sdp) != 0) {
fprintf(stderr, "Failed to compute file system constants.\n");
@@ -289,7 +288,7 @@ static int fill_super_block(struct gfs2_sbd *sdp)
perror("Failed to read superblock\n");
return 1;
}
- sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
if (sdp->master_dir == NULL) {
fprintf(stderr, "Failed to read master directory inode.\n");
return 1;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
- 1
- 0
[gfs2-utils] 20/40: libgfs2: Remove big-endian structs from struct
rgrp_tree
by pagure＠pagure.io
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 83d957c168c267d75f62e2b82fbf4e504f03dccb
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 | 48 ++++++++---
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, 542 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 30b79bc0..7afec319 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..f3d4ee78 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -177,11 +177,35 @@ 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;
+ /* 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 +214,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 +224,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 +688,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 +726,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 +771,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 +786,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 +798,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 bcc91de4..3fe8aa0a 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_data0 = be64_to_cpu(r->rg_data0);
+ rg->rt_data = be32_to_cpu(r->rg_data);
+ rg->rt_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_data0);
+ r->rg_data = cpu_to_be32(rg->rt_data);
+ r->rg_bitbytes = cpu_to_be32(rg->rt_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.
2 years, 10 months
- 1
- 0
[gfs2-utils] 19/40: libgfs2: Remove i_di from struct gfs2_inode
by pagure＠pagure.io
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 fd2951b3d419e5fe61e4245b076341d1850e21b0
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Fri May 14 15:42:30 2021 +0100
libgfs2: Remove i_di from struct gfs2_inode
To stop storing native-endian data in a struct gfs2_dinode, its fields
are duplicated into struct gfs2_inode using uint*_t types and the
in/out/print functions updated to work directly with the struct
gfs2_inode. This requires a few intermediate gfs2_inums to be used in
places that previously used i_di.di_num as a whole. They will be
resolved once a native-endian replacement for gfs2_inums is added.
Unfortunately the large size of this patch is necessary as the switch is
an all-or-nothing deal, but most of it is fairly mechanical.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/convert/gfs2_convert.c | 154 +++++++-------
gfs2/edit/extended.c | 10 +-
gfs2/edit/hexedit.c | 12 +-
gfs2/edit/journal.c | 16 +-
gfs2/fsck/afterpass1_common.c | 29 ++-
gfs2/fsck/fs_recovery.c | 29 ++-
gfs2/fsck/initialize.c | 185 ++++++++---------
gfs2/fsck/link.c | 35 ++--
gfs2/fsck/lost_n_found.c | 143 +++++++------
gfs2/fsck/main.c | 7 +-
gfs2/fsck/metawalk.c | 286 +++++++++++---------------
gfs2/fsck/pass1.c | 453 +++++++++++++++++-------------------------
gfs2/fsck/pass1b.c | 62 +++---
gfs2/fsck/pass2.c | 390 ++++++++++++++++--------------------
gfs2/fsck/pass3.c | 23 ++-
gfs2/fsck/pass4.c | 31 ++-
gfs2/fsck/rgrepair.c | 25 +--
gfs2/fsck/util.c | 47 ++---
gfs2/fsck/util.h | 12 +-
gfs2/glocktop/glocktop.c | 19 +-
gfs2/libgfs2/fs_ops.c | 215 ++++++++++----------
gfs2/libgfs2/gfs1.c | 122 +++++-------
gfs2/libgfs2/lang.c | 4 +-
gfs2/libgfs2/libgfs2.h | 42 +++-
gfs2/libgfs2/ondisk.c | 140 +++++++------
gfs2/libgfs2/recovery.c | 8 +-
gfs2/libgfs2/structures.c | 38 ++--
gfs2/libgfs2/super.c | 2 +-
gfs2/mkfs/main_mkfs.c | 11 +-
tests/nukerg.c | 2 +-
30 files changed, 1164 insertions(+), 1388 deletions(-)
diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c
index cca60598..d1cccd59 100644
--- a/gfs2/convert/gfs2_convert.c
+++ b/gfs2/convert/gfs2_convert.c
@@ -209,10 +209,10 @@ static unsigned int calc_gfs2_tree_height(struct gfs2_inode *ip, uint64_t size)
uint64_t *arr;
unsigned int max, height;
- if (ip->i_di.di_size > size)
- size = ip->i_di.di_size;
+ if (ip->i_size > size)
+ size = ip->i_size;
- if (S_ISDIR(ip->i_di.di_mode)) {
+ if (S_ISDIR(ip->i_mode)) {
arr = gfs2_jheightsize;
max = gfs2_max_jheight;
} else {
@@ -290,7 +290,7 @@ static void fix_metatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
mh.mh_magic = GFS2_MAGIC;
mh.mh_type = GFS2_METATYPE_IN;
mh.mh_format = GFS2_FORMAT_IN;
- if (!ip->i_di.di_height)
+ if (!ip->i_height)
unstuff_dinode(ip);
ptramt = blk->mp.mp_list[blk->height] * sizeof(uint64_t);
@@ -448,7 +448,7 @@ static uint64_t fix_jdatatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
mh.mh_type = GFS2_METATYPE_IN;
mh.mh_format = GFS2_FORMAT_IN;
- if (!ip->i_di.di_height)
+ if (!ip->i_height)
unstuff_dinode(ip);
ptramt = blk->mp.mp_list[blk->height];
@@ -540,7 +540,7 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip, str
osi_list_foreach(tmp, &blocks->list) {
blk = osi_list_entry(tmp, struct blocklist, list);
- if (blk->height >= ip->i_di.di_height - 1)
+ if (blk->height >= ip->i_height - 1)
continue;
for (ptr1 = (uint64_t *)blk->ptrbuf, ptrnum = 0;
ptrnum < sbp->sd_inptrs; ptr1++, ptrnum++) {
@@ -579,7 +579,7 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip, str
brelse(bh);
/* Free the block so we can reuse it. This allows us to
convert a "full" file system. */
- ip->i_di.di_blocks--;
+ ip->i_blocks--;
gfs2_free_block(sbp, block);
}
}
@@ -622,7 +622,7 @@ static int fix_ind_reg_or_dir(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint3
blk->height -= di_height - gfs2_hgt;
if (len) {
fix_metatree(sbp, ip, blk, ptr1, len);
- ip->i_di.di_goal_meta = be64_to_cpu(*ptr2);
+ ip->i_goal_meta = be64_to_cpu(*ptr2);
}
return 0;
@@ -671,7 +671,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint32_t d
newblk->mp.mp_list[h] = blk->mp.mp_list[h];
newblk->mp.mp_list[h] = ptrnum;
bh = bread(sbp, block);
- /* This is a data block. i.e newblk->height == ip->i_di.di_height */
+ /* This is a data block. i.e newblk->height == ip->i_height */
/* read in the jdata block */
memcpy(newblk->ptrbuf, bh->b_data +
sizeof(struct gfs2_meta_header), bufsize);
@@ -680,7 +680,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint32_t d
brelse(bh);
/* Free the block so we can reuse it. This allows us to
convert a "full" file system */
- ip->i_di.di_blocks--;
+ ip->i_blocks--;
gfs2_free_block(sbp, block);
len = bufsize;
@@ -689,7 +689,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint32_t d
memcpy(&newblk->mp, &gfs2mp, sizeof(struct metapath));
newblk->height -= di_height - gfs2_hgt;
if (len)
- ip->i_di.di_goal_meta = fix_jdatatree(sbp, ip, newblk,
+ ip->i_goal_meta = fix_jdatatree(sbp, ip, newblk,
newblk->ptrbuf, len);
free(newblk->ptrbuf);
free(newblk);
@@ -705,17 +705,17 @@ static int adjust_indirect_blocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip)
struct blocklist blocks, *blk;
int error = 0;
- int isdir = S_ISDIR(ip->i_di.di_mode); /* is always jdata */
- int isjdata = ((GFS2_DIF_JDATA & ip->i_di.di_flags) && !isdir);
+ int isdir = S_ISDIR(ip->i_mode); /* is always jdata */
+ int isjdata = ((GFS2_DIF_JDATA & ip->i_flags) && !isdir);
int isreg = (!isjdata && !isdir);
- int issys = (GFS2_DIF_SYSTEM & ip->i_di.di_flags);
+ int issys = (GFS2_DIF_SYSTEM & ip->i_flags);
/* regular files and dirs are same upto height=2
jdata files (not dirs) are same only when height=0 */
- if (((isreg||isdir) && ip->i_di.di_height <= 1) ||
- (isjdata && ip->i_di.di_height == 0)) {
+ if (((isreg||isdir) && ip->i_height <= 1) ||
+ (isjdata && ip->i_height == 0)) {
if (!issys)
- ip->i_di.di_goal_meta = ip->i_di.di_num.no_addr;
+ ip->i_goal_meta = ip->i_addr;
return 0; /* nothing to do */
}
@@ -727,13 +727,13 @@ static int adjust_indirect_blocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip)
/* The gfs2 height may be different. We need to rebuild the
metadata tree to the gfs2 height. */
- gfs2_hgt = calc_gfs2_tree_height(ip, ip->i_di.di_size);
+ gfs2_hgt = calc_gfs2_tree_height(ip, ip->i_size);
/* Save off the size because we're going to empty the contents
and add the data blocks back in later. */
- dinode_size = ip->i_di.di_size;
- ip->i_di.di_size = 0ULL;
- di_height = ip->i_di.di_height;
- ip->i_di.di_height = 0;
+ dinode_size = ip->i_size;
+ ip->i_size = 0ULL;
+ di_height = ip->i_height;
+ ip->i_height = 0;
/* Now run through the block list a second time. If the block
is a data block, rewrite the data to the gfs2 offset. */
@@ -762,11 +762,11 @@ static int adjust_indirect_blocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip)
free(blk);
}
- ip->i_di.di_size = dinode_size;
+ ip->i_size = dinode_size;
/* Set the new dinode height, which may or may not have changed. */
/* The caller will take it from the ip and write it to the buffer */
- ip->i_di.di_height = gfs2_hgt;
+ ip->i_height = gfs2_hgt;
return error;
out:
@@ -794,7 +794,7 @@ static int fix_cdpn_symlink(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, s
{
char *linkptr = NULL;
- if (ip->i_di.di_height != 0)
+ if (ip->i_height != 0)
return 0;
linkptr = bh->b_data + sizeof(struct gfs_dinode);
@@ -807,7 +807,7 @@ static int fix_cdpn_symlink(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, s
return -1;
}
memset(fix, 0, sizeof(struct inode_dir_block));
- fix->di_addr = ip->i_di.di_num.no_addr;
+ fix->di_addr = ip->i_addr;
osi_list_add_prev((osi_list_t *)&fix->list,
(osi_list_t *)&cdpns_to_fix);
}
@@ -817,7 +817,7 @@ static int fix_cdpn_symlink(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, s
/*
* fix_xattr -
- * Extended attributes can be either direct (in the ip->i_di.di_eattr block) or
+ * Extended attributes can be either direct (in the ip->i_eattr block) or
* then can be at a maximum of 1 indirect level. Multiple levels of indirection
* are not supported. If the di_eattr block contains extended attribute data,
* i.e block type = GFS_METATYPE_EA, we ignore it.
@@ -831,8 +831,8 @@ static int fix_xattr(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, struct g
struct gfs2_buffer_head *eabh;
char *buf;
- /* Read in the i_di.di_eattr block */
- eabh = bread(sbp, ip->i_di.di_eattr);
+ /* Read in the i_eattr block */
+ eabh = bread(sbp, ip->i_eattr);
if (!gfs2_check_meta(eabh->b_data, GFS_METATYPE_IN)) {/* if it is an indirect block */
len = sbp->bsize - sizeof(struct gfs_indirect);
buf = malloc(len);
@@ -871,16 +871,15 @@ static int adjust_inode(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh)
return -1;
}
- inode_was_gfs1 = (inode->i_di.di_num.no_formal_ino ==
- inode->i_di.di_num.no_addr);
+ inode_was_gfs1 = (inode->i_formal_ino == inode->i_addr);
/* Fix the inode number: */
- inode->i_di.di_num.no_formal_ino = sbp->md.next_inum;
+ inode->i_formal_ino = sbp->md.next_inum;
/* Fix the inode type: gfs1 uses di_type, gfs2 uses di_mode. */
- inode->i_di.di_mode &= ~S_IFMT;
- switch (inode->i_di.__pad1) { /* formerly di_type */
+ inode->i_mode &= ~S_IFMT;
+ switch (inode->i_pad1) { /* formerly di_type */
case GFS_FILE_DIR: /* directory */
- inode->i_di.di_mode |= S_IFDIR;
+ inode->i_mode |= S_IFDIR;
/* Add this directory to the list of dirs to fix later. */
fixdir = malloc(sizeof(struct inode_block));
if (!fixdir) {
@@ -889,27 +888,27 @@ static int adjust_inode(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh)
goto err_freei;
}
memset(fixdir, 0, sizeof(struct inode_block));
- fixdir->di_addr = inode->i_di.di_num.no_addr;
+ fixdir->di_addr = inode->i_addr;
osi_list_add_prev((osi_list_t *)&fixdir->list,
(osi_list_t *)&dirs_to_fix);
break;
case GFS_FILE_REG: /* regular file */
- inode->i_di.di_mode |= S_IFREG;
+ inode->i_mode |= S_IFREG;
break;
case GFS_FILE_LNK: /* symlink */
- inode->i_di.di_mode |= S_IFLNK;
+ inode->i_mode |= S_IFLNK;
break;
case GFS_FILE_BLK: /* block device */
- inode->i_di.di_mode |= S_IFBLK;
+ inode->i_mode |= S_IFBLK;
break;
case GFS_FILE_CHR: /* character device */
- inode->i_di.di_mode |= S_IFCHR;
+ inode->i_mode |= S_IFCHR;
break;
case GFS_FILE_FIFO: /* fifo / pipe */
- inode->i_di.di_mode |= S_IFIFO;
+ inode->i_mode |= S_IFIFO;
break;
case GFS_FILE_SOCK: /* socket */
- inode->i_di.di_mode |= S_IFSOCK;
+ inode->i_mode |= S_IFSOCK;
break;
}
@@ -930,25 +929,26 @@ static int adjust_inode(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh)
/* don't want to shift the data around. */
/* ----------------------------------------------------------- */
if (inode_was_gfs1) {
- struct gfs_dinode *gfs1_dinode_struct;
+ struct {
+ uint32_t dblk;
+ uint32_t mblk;
+ } *gfs1_goals = (void *)&inode->i_generation;
int ret = 0;
- gfs1_dinode_struct = (struct gfs_dinode *)&inode->i_di;
- inode->i_di.di_goal_meta = inode->i_di.di_goal_data;
- inode->i_di.di_goal_data = 0; /* make sure the upper 32b are 0 */
- inode->i_di.di_goal_data = gfs1_dinode_struct->di_goal_dblk;
- inode->i_di.di_generation = 0;
+ inode->i_goal_meta = inode->i_goal_data;
+ inode->i_goal_data = (uint64_t)gfs1_goals->dblk;
+ inode->i_generation = 0;
if (adjust_indirect_blocks(sbp, inode))
goto err_freei;
/* Check for cdpns */
- if (S_ISLNK(inode->i_di.di_mode)) {
+ if (S_ISLNK(inode->i_mode)) {
ret = fix_cdpn_symlink(sbp, bh, inode);
if (ret)
goto err_freei;
}
/* Check for extended attributes */
- if (inode->i_di.di_eattr) {
+ if (inode->i_eattr) {
ret = fix_xattr(sbp, bh, inode);
if (ret)
goto err_freei;
@@ -1124,10 +1124,10 @@ static int fetch_inum(struct gfs2_sbd *sbp, uint64_t iblock,
fix_inode = lgfs2_inode_read(sbp, iblock);
if (fix_inode == NULL)
return 1;
- inum->no_formal_ino = fix_inode->i_di.di_num.no_formal_ino;
- inum->no_addr = fix_inode->i_di.di_num.no_addr;
+ inum->no_formal_ino = fix_inode->i_formal_ino;
+ inum->no_addr = fix_inode->i_addr;
if (eablk)
- *eablk = fix_inode->i_di.di_eattr;
+ *eablk = fix_inode->i_eattr;
inode_put(&fix_inode);
return 0;
@@ -1239,7 +1239,7 @@ static int process_dirent_info(struct gfs2_inode *dip, struct gfs2_sbd *sbp,
osi_list_foreach(tmp, &cdpns_to_fix.list) {
fix = osi_list_entry(tmp, struct inode_dir_block, list);
if (fix->di_addr == inum.no_addr)
- fix->di_paddr = dip->i_di.di_num.no_addr;
+ fix->di_paddr = dip->i_addr;
}
}
@@ -1324,14 +1324,14 @@ static int process_directory(struct gfs2_sbd *sbp, uint64_t dirblock, uint64_t d
if (dip == NULL)
return -1;
/* fix the directory: either exhash (leaves) or linear (stuffed) */
- if (dip->i_di.di_flags & GFS2_DIF_EXHASH) {
+ if (dip->i_flags & GFS2_DIF_EXHASH) {
if (fix_one_directory_exhash(sbp, dip, dentmod)) {
log_crit(_("Error fixing exhash directory.\n"));
inode_put(&dip);
return -1;
}
} else {
- error = process_dirent_info(dip, sbp, dip->i_bh, dip->i_di.di_entries, dentmod);
+ error = process_dirent_info(dip, sbp, dip->i_bh, dip->i_entries, dentmod);
if (error && error != -EISDIR) {
log_crit(_("Error fixing linear directory.\n"));
inode_put(&dip);
@@ -1430,7 +1430,7 @@ static int fix_cdpn_symlinks(struct gfs2_sbd *sbp, osi_list_t *cdpn_to_fix)
fix_inode = lgfs2_inode_get(sbp, bh);
if (fix_inode == NULL)
return -1;
- fix_inode->i_di.di_eattr = eablk; /*fix extended attribute */
+ fix_inode->i_eattr = eablk; /*fix extended attribute */
inode_put(&fix_inode);
bmodified(bh);
brelse(bh);
@@ -1471,17 +1471,17 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
int error=0;
unsigned int tmp_mode = 0;
- if(ip->i_di.di_size % sizeof(struct gfs_jindex) != 0){
+ if(ip->i_size % sizeof(struct gfs_jindex) != 0){
log_crit(_("The size reported in the journal index"
" inode is not a\n"
"\tmultiple of the size of a journal index.\n"));
return -1;
}
- if(!(sd_jindex = (struct gfs_jindex *)malloc(ip->i_di.di_size))) {
+ if(!(sd_jindex = (struct gfs_jindex *)malloc(ip->i_size))) {
log_crit(_("Unable to allocate journal index\n"));
return -1;
}
- if(!memset(sd_jindex, 0, ip->i_di.di_size)) {
+ if(!memset(sd_jindex, 0, ip->i_size)) {
log_crit(_("Unable to zero journal index\n"));
return -1;
}
@@ -1490,9 +1490,9 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
* so it skips the metaheader struct in the data blocks
* in the inode. gfs2_jindex inode doesn't have metaheaders
* in the data blocks */
- tmp_mode = ip->i_di.di_mode;
- ip->i_di.di_mode &= ~S_IFMT;
- ip->i_di.di_mode |= S_IFDIR;
+ tmp_mode = ip->i_mode;
+ ip->i_mode &= ~S_IFMT;
+ ip->i_mode |= S_IFDIR;
for (j = 0; ; j++) {
struct gfs_jindex *journ;
@@ -1509,8 +1509,8 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
gfs1_jindex_in(journ, buf);
sdp->jsize = (journ->ji_nsegment * 16 * sdp->bsize) >> 20;
}
- ip->i_di.di_mode = tmp_mode;
- if(j * sizeof(struct gfs_jindex) != ip->i_di.di_size){
+ ip->i_mode = tmp_mode;
+ if(j * sizeof(struct gfs_jindex) != ip->i_size){
log_crit(_("journal inode size invalid\n"));
goto fail;
}
@@ -1710,8 +1710,8 @@ static int init(struct gfs2_sbd *sbp, struct gfs2_options *opts)
/* apparently only for directories. So we need to fake out libgfs2 */
/* so that it adjusts for the metaheader by faking out the inode to */
/* look like a directory, temporarily. */
- sbp->md.riinode->i_di.di_mode &= ~S_IFMT;
- sbp->md.riinode->i_di.di_mode |= S_IFDIR;
+ sbp->md.riinode->i_mode &= ~S_IFMT;
+ sbp->md.riinode->i_mode |= S_IFDIR;
printf(_("Examining file system"));
if (gfs1_ri_update(sbp, &rgcount, 0)){
log_crit(_("Unable to fill in resource group information.\n"));
@@ -2158,15 +2158,15 @@ static void copy_quotas(struct gfs2_sbd *sdp)
exit(1);
}
- nq_ip->i_di.di_height = oq_ip->i_di.di_height;
- nq_ip->i_di.di_size = oq_ip->i_di.di_size;
- nq_ip->i_di.di_blocks = oq_ip->i_di.di_blocks;
+ nq_ip->i_height = oq_ip->i_height;
+ nq_ip->i_size = oq_ip->i_size;
+ nq_ip->i_blocks = oq_ip->i_blocks;
memcpy(nq_ip->i_bh->b_data + sizeof(struct gfs2_dinode),
oq_ip->i_bh->b_data + sizeof(struct gfs2_dinode),
sdp->bsize - sizeof(struct gfs2_dinode));
- oq_ip->i_di.di_height = 0;
- oq_ip->i_di.di_size = 0;
+ oq_ip->i_height = 0;
+ oq_ip->i_size = 0;
bmodified(nq_ip->i_bh);
inode_put(&nq_ip);
@@ -2321,7 +2321,8 @@ int main(int argc, char **argv)
"GFS2 file system structures.\n"), sb2.jsize);
/* Build the master subdirectory. */
build_master(&sb2); /* Does not do inode_put */
- sb2.sd_sb.sb_master_dir = sb2.master_dir->i_di.di_num;
+ sb2.sd_sb.sb_master_dir.no_addr = sb2.master_dir->i_addr;
+ sb2.sd_sb.sb_master_dir.no_formal_ino = sb2.master_dir->i_formal_ino;
/* Build empty journal index file. */
error = conv_build_jindex(&sb2);
if (error) {
@@ -2370,11 +2371,8 @@ int main(int argc, char **argv)
}
/* Copy out the master dinode */
- {
- struct gfs2_inode *ip = sb2.master_dir;
- if (ip->i_bh->b_modified)
- gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data);
- }
+ if (sb2.master_dir->i_bh->b_modified)
+ lgfs2_dinode_out(sb2.master_dir, sb2.master_dir->i_bh->b_data);
/* Copy old quotas */
copy_quotas(&sb2);
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index c977b6e1..f3b1bba0 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -439,7 +439,7 @@ static int print_gfs_jindex(struct gfs2_inode *dij)
start_line = line;
print_gfs2("Journal index entries found: %"PRIu64".",
- dij->i_di.di_size / sizeof(struct gfs_jindex));
+ dij->i_size / sizeof(struct gfs_jindex));
eol(0);
lines_per_row[dmode] = 4;
for (print_entry_ndx=0; ; print_entry_ndx++) {
@@ -483,7 +483,7 @@ static int print_gfs2_jindex(void)
print_gfs2("%s: 0x%-5"PRIx64" %"PRIu64"MB ",
indirect->ii[0].dirent[d].filename,
indirect->ii[0].dirent[d].block,
- ip->i_di.di_size / 1048576);
+ ip->i_size / 1048576);
error = lgfs2_find_jhead(ip, &head);
if (error) {
print_gfs2("corrupt.");
@@ -507,8 +507,8 @@ static int parse_rindex(struct gfs2_inode *dip, int print_rindex)
char highlighted_addr[32];
start_line = line;
- print_gfs2("RG index entries found: %"PRIu64".", dip->i_di.di_size /
- sizeof(struct gfs2_rindex));
+ print_gfs2("RG index entries found: %"PRIu64".",
+ dip->i_size / sizeof(struct gfs2_rindex));
eol(0);
lines_per_row[dmode] = 6;
memset(highlighted_addr, 0, sizeof(highlighted_addr));
@@ -612,7 +612,7 @@ static int print_quota(struct gfs2_inode *diq)
print_gfs2("quota file contents:");
eol(0);
- print_gfs2("quota entries found: %"PRIu64".", diq->i_di.di_size / sizeof(q));
+ print_gfs2("quota entries found: %"PRIu64".", diq->i_size / sizeof(q));
eol(0);
for (i=0; ; i++) {
error = gfs2_readi(diq, &q, i * sizeof(q), sizeof(q));
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index 2e647211..4fbe071d 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -696,9 +696,8 @@ uint64_t masterblock(const char *fn)
/* ------------------------------------------------------------------------ */
static void rgcount(void)
{
- printf("%lld RGs in this file system.\n",
- (unsigned long long)sbd.md.riinode->i_di.di_size /
- sizeof(struct gfs2_rindex));
+ printf("%"PRId64" RGs in this file system.\n",
+ sbd.md.riinode->i_size / sizeof(struct gfs2_rindex));
inode_put(&sbd.md.riinode);
gfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_SUCCESS);
@@ -762,12 +761,11 @@ static uint64_t get_rg_addr(int rgnum)
riinode = lgfs2_inode_read(&sbd, gblock);
if (riinode == NULL)
return 0;
- if (rgnum < riinode->i_di.di_size / sizeof(struct gfs2_rindex))
+ if (rgnum < riinode->i_size / sizeof(struct gfs2_rindex))
rgblk = find_rgrp_block(riinode, rgnum);
else
- fprintf(stderr, "Error: File system only has %lld RGs.\n",
- (unsigned long long)riinode->i_di.di_size /
- sizeof(struct gfs2_rindex));
+ fprintf(stderr, "Error: File system only has %"PRId64" RGs.\n",
+ riinode->i_size / sizeof(struct gfs2_rindex));
inode_put(&riinode);
return rgblk;
}
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index 607f65e5..13b8c121 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -73,14 +73,14 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size)
}
inode_put(&jiinode);
} else {
- struct gfs2_dinode jdi;
+ struct gfs2_dinode *jdi;
if (journal_num > indirect->ii[0].dirents - 2)
return 0;
jblock = indirect->ii[0].dirent[journal_num + 2].block;
j_bh = bread(&sbd, jblock);
- gfs2_dinode_in(&jdi, j_bh->b_data);
- *j_size = jdi.di_size;
+ jdi = (struct gfs2_dinode *)j_bh->b_data;
+ *j_size = be64_to_cpu(jdi->di_size);
brelse(j_bh);
}
brelse(jindex_bh);
@@ -122,12 +122,12 @@ static int fsck_readi(struct gfs2_inode *ip, void *rbuf, uint64_t roffset,
if (ip == NULL)
return 0;
sdp = ip->i_sbd;
- isdir = !!(S_ISDIR(ip->i_di.di_mode));
+ isdir = !!(S_ISDIR(ip->i_mode));
*abs_block = 0;
- if (roffset >= ip->i_di.di_size)
+ if (roffset >= ip->i_size)
return 0;
- if ((roffset + size) > ip->i_di.di_size)
- size = ip->i_di.di_size - roffset;
+ if ((roffset + size) > ip->i_size)
+ size = ip->i_size - roffset;
if (!size)
return 0;
if (isdir) {
@@ -138,7 +138,7 @@ static int fsck_readi(struct gfs2_inode *ip, void *rbuf, uint64_t roffset,
o = roffset & (sdp->bsize - 1);
}
- if (!ip->i_di.di_height) /* inode_is_stuffed */
+ if (!ip->i_height) /* inode_is_stuffed */
o += sizeof(struct gfs2_dinode);
else if (isdir)
o += sizeof(struct gfs2_meta_header);
diff --git a/gfs2/fsck/afterpass1_common.c b/gfs2/fsck/afterpass1_common.c
index 82b9a54c..35029202 100644
--- a/gfs2/fsck/afterpass1_common.c
+++ b/gfs2/fsck/afterpass1_common.c
@@ -86,12 +86,9 @@ static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t block,
q = bitmap_type(ip->i_sbd, block);
if (q == GFS2_BLKST_FREE) {
- log_info( _("%s block %lld (0x%llx), part of inode "
- "%lld (0x%llx), was already free.\n"),
- btype, (unsigned long long)block,
- (unsigned long long)block,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_info(_("%s block %"PRIu64" (0x%"PRIx64"), part of inode "
+ "%"PRIu64" (0x%"PRIx64"), was already free.\n"),
+ btype, block, block, ip->i_addr, ip->i_addr);
return META_IS_GOOD;
}
if (find_remove_dup(ip, block, btype, &removed_lastmeta)) { /* a dup */
@@ -101,12 +98,10 @@ static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t block,
else
*was_duplicate = 1;
}
- log_err( _("Not clearing duplicate reference in inode "
- "at block #%llu (0x%llx) to block #%llu (0x%llx) "
- "because it's referenced by another inode.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)block, (unsigned long long)block);
+ log_err(_("Not clearing duplicate reference in inode at block #%"PRIu64
+ " (0x%"PRIx64") to block #%"PRIu64" (0x%"PRIx64") "
+ "because it's referenced by another inode.\n"),
+ ip->i_addr, ip->i_addr, block, block);
} else {
check_n_fix_bitmap(ip->i_sbd, ip->i_rgd, block, 0,
GFS2_BLKST_FREE);
@@ -218,15 +213,15 @@ static int del_eattr_generic(struct gfs2_inode *ip, uint64_t block,
if (!ret) {
*bh = bread(ip->i_sbd, block);
if (!was_free)
- ip->i_di.di_blocks--;
+ ip->i_blocks--;
bmodified(ip->i_bh);
}
}
/* Even if it's a duplicate reference, we want to eliminate the
reference itself, and adjust di_blocks accordingly. */
- if (ip->i_di.di_eattr) {
- if (block == ip->i_di.di_eattr)
- ip->i_di.di_eattr = 0;
+ if (ip->i_eattr) {
+ if (block == ip->i_eattr)
+ ip->i_eattr = 0;
bmodified(ip->i_bh);
}
return ret;
@@ -308,7 +303,7 @@ int delete_eattr_extentry(struct gfs2_inode *ip, int i, uint64_t *ea_data_ptr,
bmodified(leaf_bh);
/* Endianness doesn't matter in this case because it's
a single byte. */
- fsck_bitmap_set(ip, ip->i_di.di_eattr,
+ fsck_bitmap_set(ip, ip->i_eattr,
_("extended attribute"),
ip->i_sbd->gfs1 ? GFS2_BLKST_DINODE :
GFS2_BLKST_USED);
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index 6251ba90..30b79bc0 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -399,7 +399,7 @@ static int foreach_descriptor(struct gfs2_inode *ip, unsigned int start,
static int check_journal_seq_no(struct gfs2_inode *ip, int fix)
{
int error = 0, wrapped = 0;
- uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
uint32_t blk;
struct lgfs2_log_header lh;
uint64_t highest_seq = 0, lowest_seq = 0, prev_seq = 0;
@@ -609,7 +609,7 @@ out:
reinit:
if (query( _("Do you want to clear the journal instead? (y/n)"))) {
error = write_journal(sdp->md.journal[j], sdp->bsize,
- sdp->md.journal[j]->i_di.di_size /
+ sdp->md.journal[j]->i_size /
sdp->sd_sb.sb_bsize);
log_err(_("jid=%u: journal was cleared.\n"), j);
} else {
@@ -624,9 +624,8 @@ static int rangecheck_jblock(struct gfs2_inode *ip, uint64_t block)
{
if((block > ip->i_sbd->fssize) || (block <= LGFS2_SB_ADDR(ip->i_sbd))) {
log_info( _("Bad block pointer (out of range) found in "
- "journal inode %lld (0x%llx).\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ "journal inode %"PRIu64" (0x%"PRIx64").\n"),
+ ip->i_addr, ip->i_addr);
return META_ERROR; /* Exits check_metatree quicker */
}
return META_IS_GOOD;
@@ -647,14 +646,11 @@ static int rangecheck_jmeta(struct iptr iptr, struct gfs2_buffer_head **bh, int
*bh = bread(ip->i_sbd, block);
*is_valid = (gfs2_check_meta((*bh)->b_data, GFS2_METATYPE_IN) == 0);
if (!(*is_valid)) {
- log_err( _("Journal at block %lld (0x%llx) has a bad "
- "indirect block pointer %lld (0x%llx) "
+ log_err( _("Journal at block %"PRIu64" (0x%"PRIx64") has a bad "
+ "indirect block pointer %"PRIu64" (0x%"PRIx64") "
"(points to something that is not an "
"indirect block).\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)block,
- (unsigned long long)block);
+ ip->i_addr, ip->i_addr, block, block);
brelse(*bh);
*bh = NULL;
return META_SKIP_FURTHER;
@@ -717,8 +713,7 @@ int replay_journals(struct gfs2_sbd *sdp, int preen, int force_check,
continue;
}
if (!error) {
- uint64_t jsize = sdp->md.journal[i]->i_di.di_size /
- (1024 * 1024);
+ uint64_t jsize = sdp->md.journal[i]->i_size / (1024 * 1024);
if (sdp->jsize == GFS2_DEFAULT_JSIZE && jsize &&
jsize != sdp->jsize)
@@ -769,11 +764,11 @@ int ji_update(struct gfs2_sbd *sdp)
If per_node is missing or damaged, we have to trust jindex has
the correct number of entries. */
if (sdp->gfs1)
- sdp->md.journals = ip->i_di.di_size / sizeof(struct gfs_jindex);
+ sdp->md.journals = ip->i_size / sizeof(struct gfs_jindex);
else if (sdp->md.pinode) /* if per_node was read in properly */
- sdp->md.journals = (sdp->md.pinode->i_di.di_entries - 2) / 3;
+ sdp->md.journals = (sdp->md.pinode->i_entries - 2) / 3;
else
- sdp->md.journals = ip->i_di.di_entries - 2;
+ sdp->md.journals = ip->i_entries - 2;
if (!(sdp->md.journal = calloc(sdp->md.journals,
sizeof(struct gfs2_inode *)))) {
@@ -911,7 +906,7 @@ int init_jindex(struct gfs2_sbd *sdp, int allow_ji_rebuild)
int error;
log_debug(_("Checking the integrity of the journal index.\n"));
- if (sdp->md.jiinode->i_di.di_flags & GFS2_DIF_EXHASH)
+ if (sdp->md.jiinode->i_flags & GFS2_DIF_EXHASH)
error = check_leaf_blks(sdp->md.jiinode,
&jindex_check_fxns);
else
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 1a6db6ec..3f2c088b 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -301,10 +301,9 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
if (!gfs2_check_meta(bh->b_data, GFS2_METATYPE_DI)) {
struct gfs2_inode *ip =
fsck_inode_get(sdp, rgd, bh);
- if (ip->i_di.di_blocks > 1) {
- blks_2free +=
- ip->i_di.di_blocks - 1;
- log_info(_("%lld blocks "
+ if (ip->i_blocks > 1) {
+ blks_2free += ip->i_blocks - 1;
+ log_info(_("%llu blocks "
"(total) may need "
"to be freed in "
"pass 5.\n"),
@@ -492,14 +491,14 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.jiinode) {
inum.no_formal_ino = sdp->md.next_inum++;
- inum.no_addr = fix_md.jiinode->i_di.di_num.no_addr;
+ inum.no_addr = fix_md.jiinode->i_addr;
err = dir_add(sdp->master_dir, "jindex", 6, &inum,
IF2DT(S_IFDIR | 0700));
if (err) {
log_crit(_("Error %d adding jindex directory\n"), errno);
exit(FSCK_ERROR);
}
- sdp->master_dir->i_di.di_nlink++;
+ sdp->master_dir->i_nlink++;
} else {
err = build_jindex(sdp);
if (err) {
@@ -510,7 +509,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.pinode) {
inum.no_formal_ino = sdp->md.next_inum++;
- inum.no_addr = fix_md.pinode->i_di.di_num.no_addr;
+ inum.no_addr = fix_md.pinode->i_addr;
err = dir_add(sdp->master_dir, "per_node", 8, &inum,
IF2DT(S_IFDIR | 0700));
if (err) {
@@ -518,7 +517,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
errno);
exit(FSCK_ERROR);
}
- sdp->master_dir->i_di.di_nlink++;
+ sdp->master_dir->i_nlink++;
} else {
err = build_per_node(sdp);
if (err) {
@@ -530,7 +529,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.inum) {
inum.no_formal_ino = sdp->md.next_inum++;
- inum.no_addr = fix_md.inum->i_di.di_num.no_addr;
+ inum.no_addr = fix_md.inum->i_addr;
err = dir_add(sdp->master_dir, "inum", 4, &inum,
IF2DT(S_IFREG | 0600));
if (err) {
@@ -548,7 +547,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.statfs) {
inum.no_formal_ino = sdp->md.next_inum++;
- inum.no_addr = fix_md.statfs->i_di.di_num.no_addr;
+ inum.no_addr = fix_md.statfs->i_addr;
err = dir_add(sdp->master_dir, "statfs", 6, &inum,
IF2DT(S_IFREG | 0600));
if (err) {
@@ -566,7 +565,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.riinode) {
inum.no_formal_ino = sdp->md.next_inum++;
- inum.no_addr = fix_md.riinode->i_di.di_num.no_addr;
+ inum.no_addr = fix_md.riinode->i_addr;
err = dir_add(sdp->master_dir, "rindex", 6, &inum,
IF2DT(S_IFREG | 0600));
if (err) {
@@ -583,7 +582,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.qinode) {
inum.no_formal_ino = sdp->md.next_inum++;
- inum.no_addr = fix_md.qinode->i_di.di_num.no_addr;
+ inum.no_addr = fix_md.qinode->i_addr;
err = dir_add(sdp->master_dir, "quota", 5, &inum,
IF2DT(S_IFREG | 0600));
if (err) {
@@ -850,8 +849,8 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
}
/* Read inum entry into buffer */
err = gfs2_readi(sdp->md.inum, &inumbuf, 0,
- sdp->md.inum->i_di.di_size);
- if (err != sdp->md.inum->i_di.di_size) {
+ sdp->md.inum->i_size);
+ if (err != sdp->md.inum->i_size) {
log_crit(_("Error %d reading system inum inode. "
"Aborting.\n"), err);
goto fail;
@@ -902,12 +901,12 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
}
do_init_statfs(sdp);
}
- if (sdp->md.statfs->i_di.di_size) {
- buf = malloc(sdp->md.statfs->i_di.di_size);
+ if (sdp->md.statfs->i_size) {
+ buf = malloc(sdp->md.statfs->i_size);
if (buf) {
err = gfs2_readi(sdp->md.statfs, buf, 0,
- sdp->md.statfs->i_di.di_size);
- if (err != sdp->md.statfs->i_di.di_size) {
+ sdp->md.statfs->i_size);
+ if (err != sdp->md.statfs->i_size) {
log_crit(_("Error %d reading statfs file. "
"Aborting.\n"), err);
free(buf);
@@ -984,9 +983,9 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
* A real dinode will be located at the block number in its no_addr.
* A journal-copy will be at a different block (inside the journal).
*/
-static int is_journal_copy(struct gfs2_inode *ip, struct gfs2_buffer_head *bh)
+static int is_journal_copy(struct gfs2_inode *ip)
{
- if (ip->i_di.di_num.no_addr == bh->b_blocknr)
+ if (ip->i_addr == ip->i_bh->b_blocknr)
return 0;
return 1; /* journal copy */
}
@@ -1001,47 +1000,40 @@ static int is_journal_copy(struct gfs2_inode *ip, struct gfs2_buffer_head *bh)
* the per_node directory will have a ".." entry that will lead us to
* the master dinode if it's been destroyed.
*/
-static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
- struct gfs2_buffer_head *bh)
+static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
{
- struct gfs2_inode *ip, *child_ip;
+ struct gfs2_inode *child_ip;
struct gfs2_inum inum;
int error;
- if (di->di_num.no_formal_ino == 2) {
+ if (ip->i_formal_ino == 2) {
if (sdp->sd_sb.sb_master_dir.no_addr)
return;
log_warn(_("Found system master directory at: 0x%"PRIx64".\n"),
- di->di_num.no_addr);
- sdp->sd_sb.sb_master_dir.no_addr = di->di_num.no_addr;
+ ip->i_addr);
+ sdp->sd_sb.sb_master_dir.no_addr = ip->i_addr;
return;
}
- ip = lgfs2_inode_read(sdp, di->di_num.no_addr);
- if (ip == NULL) {
- log_crit(_("Error reading inode: %s\n"), strerror(errno));
- return;
- }
- if ((!sdp->gfs1 && di->di_num.no_formal_ino == 3) ||
- (sdp->gfs1 && (di->di_flags & GFS2_DIF_JDATA) &&
- (di->di_size % sizeof(struct gfs_jindex) == 0))) {
- if (fix_md.jiinode || is_journal_copy(ip, bh))
+ if ((!sdp->gfs1 && ip->i_formal_ino == 3) ||
+ (sdp->gfs1 && (ip->i_flags & GFS2_DIF_JDATA) &&
+ (ip->i_size % sizeof(struct gfs_jindex) == 0))) {
+ if (fix_md.jiinode || is_journal_copy(ip))
goto out_discard_ip;
- log_warn(_("Found system jindex file at: 0x%"PRIx64"\n"),
- di->di_num.no_addr);
+ log_warn(_("Found system jindex file at: 0x%"PRIx64"\n"), ip->i_addr);
fix_md.jiinode = ip;
- } else if (!sdp->gfs1 && is_dir(di, sdp->gfs1)) {
+ } else if (!sdp->gfs1 && is_dir(ip, sdp->gfs1)) {
/* Check for a jindex dir entry. Only one system dir has a
jindex: master */
gfs2_lookupi(ip, "jindex", 6, &child_ip);
if (child_ip) {
- if (fix_md.jiinode || is_journal_copy(ip, bh)) {
+ if (fix_md.jiinode || is_journal_copy(ip)) {
inode_put(&child_ip);
goto out_discard_ip;
}
fix_md.jiinode = child_ip;
- sdp->sd_sb.sb_master_dir.no_addr = di->di_num.no_addr;
+ sdp->sd_sb.sb_master_dir.no_addr = ip->i_addr;
log_warn(_("Found system master directory at: 0x%"PRIx64"\n"),
- di->di_num.no_addr);
+ ip->i_addr);
return;
}
@@ -1050,10 +1042,10 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
gfs2_lookupi(ip, "statfs_change0", 14, &child_ip);
if (child_ip) {
inode_put(&child_ip);
- if (fix_md.pinode || is_journal_copy(ip, bh))
+ if (fix_md.pinode || is_journal_copy(ip))
goto out_discard_ip;
log_warn(_("Found system per_node directory at: 0x%"PRIx64"\n"),
- ip->i_di.di_num.no_addr);
+ ip->i_addr);
fix_md.pinode = ip;
error = dir_search(ip, "..", 2, NULL, &inum);
if (!error && inum.no_addr) {
@@ -1064,35 +1056,30 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
}
return;
}
- log_debug(_("Unknown system directory at block 0x%"PRIx64"\n"),
- di->di_num.no_addr);
+ log_debug(_("Unknown system directory at block 0x%"PRIx64"\n"), ip->i_addr);
goto out_discard_ip;
- } else if (!sdp->gfs1 && di->di_size == 8) {
- if (fix_md.inum || is_journal_copy(ip, bh))
+ } else if (!sdp->gfs1 && ip->i_size == 8) {
+ if (fix_md.inum || is_journal_copy(ip))
goto out_discard_ip;
fix_md.inum = ip;
- log_warn(_("Found system inum file at: 0x%"PRIx64"\n"),
- di->di_num.no_addr);
- } else if (di->di_size == 24) {
- if (fix_md.statfs || is_journal_copy(ip, bh))
+ log_warn(_("Found system inum file at: 0x%"PRIx64"\n"), ip->i_addr);
+ } else if (ip->i_size == 24) {
+ if (fix_md.statfs || is_journal_copy(ip))
goto out_discard_ip;
fix_md.statfs = ip;
- log_warn(_("Found system statfs file at: 0x%"PRIx64"\n"),
- di->di_num.no_addr);
- } else if ((di->di_size % 96) == 0) {
- if (fix_md.riinode || is_journal_copy(ip, bh))
+ log_warn(_("Found system statfs file at: 0x%"PRIx64"\n"), ip->i_addr);
+ } else if ((ip->i_size % 96) == 0) {
+ if (fix_md.riinode || is_journal_copy(ip))
goto out_discard_ip;
fix_md.riinode = ip;
- log_warn(_("Found system rindex file at: 0x%"PRIx64"\n"),
- di->di_num.no_addr);
- } else if (!fix_md.qinode && di->di_size >= 176 &&
- di->di_num.no_formal_ino >= 12 &&
- di->di_num.no_formal_ino <= 100) {
- if (is_journal_copy(ip, bh))
+ log_warn(_("Found system rindex file at: 0x%"PRIx64"\n"), ip->i_addr);
+ } else if (!fix_md.qinode && ip->i_size >= 176 &&
+ ip->i_formal_ino >= 12 &&
+ ip->i_formal_ino <= 100) {
+ if (is_journal_copy(ip))
goto out_discard_ip;
fix_md.qinode = ip;
- log_warn(_("Found system quota file at: 0x%"PRIx64"\n"),
- di->di_num.no_addr);
+ log_warn(_("Found system quota file at: 0x%"PRIx64"\n"), ip->i_addr);
} else {
out_discard_ip:
inode_put(&ip);
@@ -1103,58 +1090,49 @@ out_discard_ip:
* peruse_user_dinode - process a user dinode trying to find the root directory
*
*/
-static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
- struct gfs2_buffer_head *bh)
+static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
{
- struct gfs2_inode *ip, *parent_ip;
+ struct gfs2_inode *parent_ip;
struct gfs2_inum inum;
int error;
if (sdp->sd_sb.sb_root_dir.no_addr) /* if we know the root dinode */
return; /* we don't need to find the root */
- if (!is_dir(di, sdp->gfs1)) /* if this isn't a directory */
+ if (!is_dir(ip, sdp->gfs1)) /* if this isn't a directory */
return; /* it can't lead us to the root anyway */
- if (di->di_num.no_formal_ino == 1) {
+ if (ip->i_formal_ino == 1) {
struct gfs2_buffer_head *root_bh;
- if (di->di_num.no_addr == bh->b_blocknr) {
+ if (ip->i_addr == ip->i_bh->b_blocknr) {
log_warn(_("Found the root directory at: 0x%"PRIx64".\n"),
- di->di_num.no_addr);
- sdp->sd_sb.sb_root_dir.no_addr = di->di_num.no_addr;
+ ip->i_addr);
+ sdp->sd_sb.sb_root_dir.no_addr = ip->i_addr;
return;
}
log_warn(_("The root dinode should be at block 0x%"PRIx64" but it "
"seems to be destroyed.\n"),
- di->di_num.no_addr);
+ ip->i_addr);
log_warn(_("Found a copy of the root directory in a journal "
"at block: 0x%"PRIx64".\n"),
- bh->b_blocknr);
- if (!query(_("Do you want to replace the root dinode from the "
- "copy? (y/n)"))) {
+ ip->i_bh->b_blocknr);
+ if (!query(_("Do you want to replace the root dinode from the copy? (y/n)"))) {
log_err(_("Damaged root dinode not fixed.\n"));
return;
}
- root_bh = bread(sdp, di->di_num.no_addr);
- memcpy(root_bh->b_data, bh->b_data, sdp->bsize);
+ root_bh = bread(sdp, ip->i_addr);
+ memcpy(root_bh->b_data, ip->i_bh->b_data, sdp->bsize);
bmodified(root_bh);
brelse(root_bh);
log_warn(_("Root directory copied from the journal.\n"));
return;
}
- ip = lgfs2_inode_read(sdp, di->di_num.no_addr);
- if (ip == NULL) {
- log_crit(_("Error reading inode: %s\n"), strerror(errno));
- return;
- }
while (ip) {
gfs2_lookupi(ip, "..", 2, &parent_ip);
- if (parent_ip && parent_ip->i_di.di_num.no_addr ==
- ip->i_di.di_num.no_addr) {
+ if (parent_ip && parent_ip->i_addr == ip->i_addr) {
log_warn(_("Found the root directory at: 0x%"PRIx64"\n"),
- ip->i_di.di_num.no_addr);
- sdp->sd_sb.sb_root_dir.no_addr =
- ip->i_di.di_num.no_addr;
+ ip->i_addr);
+ sdp->sd_sb.sb_root_dir.no_addr = ip->i_addr;
inode_put(&parent_ip);
inode_put(&ip);
return;
@@ -1250,7 +1228,7 @@ static int peruse_metadata(struct gfs2_sbd *sdp, uint64_t startblock)
{
uint64_t blk, max_rg_size;
struct gfs2_buffer_head *bh;
- struct gfs2_dinode di;
+ struct gfs2_inode *ip;
max_rg_size = 2147483648ull / sdp->bsize;
/* Max RG size is 2GB. 2G / bsize. */
@@ -1260,12 +1238,12 @@ static int peruse_metadata(struct gfs2_sbd *sdp, uint64_t startblock)
brelse(bh);
continue;
}
- gfs2_dinode_in(&di, bh->b_data);
- if (di.di_flags & GFS2_DIF_SYSTEM)
- peruse_system_dinode(sdp, &di, bh);
+ ip = lgfs2_inode_get(sdp, bh);
+ ip->bh_owned = 1; /* inode_put() will free the bh */
+ if (ip->i_flags & GFS2_DIF_SYSTEM)
+ peruse_system_dinode(sdp, ip);
else
- peruse_user_dinode(sdp, &di, bh);
- brelse(bh);
+ peruse_user_dinode(sdp, ip);
}
return 0;
}
@@ -1331,8 +1309,7 @@ static int sb_repair(struct gfs2_sbd *sdp)
(unsigned long long)possible_root);
sdp->sd_sb.sb_root_dir.no_addr = possible_root;
sdp->md.rooti = lgfs2_inode_read(sdp, possible_root);
- if (!sdp->md.rooti ||
- sdp->md.rooti->i_di.di_header.mh_magic != GFS2_MAGIC) {
+ if (!sdp->md.rooti || sdp->md.rooti->i_magic != GFS2_MAGIC) {
struct gfs2_buffer_head *bh = NULL;
log_err(_("The root dinode block is destroyed.\n"));
@@ -1365,8 +1342,7 @@ static int sb_repair(struct gfs2_sbd *sdp)
log_crit(_("Error reading master inode: %s\n"), strerror(errno));
return -1;
}
- sdp->master_dir->i_di.di_num.no_addr =
- sdp->sd_sb.sb_master_dir.no_addr;
+ sdp->master_dir->i_addr = sdp->sd_sb.sb_master_dir.no_addr;
log_info(_("Found the root directory at: 0x%"PRIx64"\n"),
sdp->sd_sb.sb_root_dir.no_addr);
sdp->md.rooti = lgfs2_inode_read(sdp,
@@ -1378,8 +1354,10 @@ static int sb_repair(struct gfs2_sbd *sdp)
lgfs2_sb_init(&sb, sdp->bsize, GFS2_FORMAT_FS);
strcpy(sb.sb_lockproto, GFS2_DEFAULT_LOCKPROTO);
strcpy(sb.sb_locktable, "unknown");
- sb.sb_master_dir = sdp->master_dir->i_di.di_num;
- sb.sb_root_dir = sdp->md.rooti->i_di.di_num;
+ sb.sb_master_dir.no_addr = sdp->master_dir->i_addr;
+ sb.sb_master_dir.no_formal_ino = sdp->master_dir->i_formal_ino;
+ sb.sb_root_dir.no_addr = sdp->md.rooti->i_addr;
+ sb.sb_root_dir.no_formal_ino = sdp->md.rooti->i_formal_ino;
lgfs2_sb_write(&sb, sdp->device_fd, sdp->bsize);
inode_put(&sdp->md.rooti);
inode_put(&sdp->master_dir);
@@ -1493,8 +1471,7 @@ static int reconstruct_single_journal(struct gfs2_sbd *sdp, int jnum,
lh.lh_header.mh_format = GFS2_FORMAT_LH;
lh.lh_header.__pad0 = 0x101674; /* mh_generation */
lh.lh_flags = GFS2_LOG_HEAD_UNMOUNT;
- lh.lh_first = sdp->md.journal[jnum]->i_di.di_num.no_addr +
- (seg * sbd1->sb_seg_size);
+ lh.lh_first = sdp->md.journal[jnum]->i_addr + (seg * sbd1->sb_seg_size);
lh.lh_sequence = sequence;
bh = bget(sdp, lh.lh_first * sdp->bsize);
@@ -1711,9 +1688,9 @@ int initialize(struct gfs2_sbd *sdp, int force_check, int preen,
sdp->master_dir = lgfs2_inode_read(sdp,
sdp->sd_sb.sb_master_dir.no_addr);
if (!sdp->gfs1 &&
- (sdp->master_dir->i_di.di_header.mh_magic != GFS2_MAGIC ||
- sdp->master_dir->i_di.di_header.mh_type != GFS2_METATYPE_DI ||
- !sdp->master_dir->i_di.di_size)) {
+ (sdp->master_dir->i_magic != GFS2_MAGIC ||
+ sdp->master_dir->i_type != GFS2_METATYPE_DI ||
+ !sdp->master_dir->i_size)) {
inode_put(&sdp->master_dir);
rebuild_master(sdp);
sdp->master_dir = lgfs2_inode_read(sdp,
diff --git a/gfs2/fsck/link.c b/gfs2/fsck/link.c
index 08118e8a..1c5ec3d2 100644
--- a/gfs2/fsck/link.c
+++ b/gfs2/fsck/link.c
@@ -40,30 +40,34 @@ int set_di_nlink(struct gfs2_inode *ip)
struct inode_info *ii;
struct dir_info *di;
- if (is_dir(&ip->i_di, ip->i_sbd->gfs1)) {
- di = dirtree_find(ip->i_di.di_num.no_addr);
+ if (is_dir(ip, ip->i_sbd->gfs1)) {
+ di = dirtree_find(ip->i_addr);
if (di == NULL) {
- log_err(_("Error: directory %lld (0x%llx) is not "
+ log_err(_("Error: directory %"PRIu64" (0x%"PRIx64") is not "
"in the dir_tree (set).\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ ip->i_addr, ip->i_addr);
return -1;
}
- di->di_nlink = ip->i_di.di_nlink;
+ di->di_nlink = ip->i_nlink;
return 0;
}
- if (ip->i_di.di_nlink == 1) {
- link1_set(&nlink1map, ip->i_di.di_num.no_addr, 1);
+ if (ip->i_nlink == 1) {
+ link1_set(&nlink1map, ip->i_addr, 1);
return 0;
}
/*log_debug( _("Setting link count to %u for %" PRIu64
" (0x%" PRIx64 ")\n"), count, inode_no, inode_no);*/
/* If the list has entries, look for one that matches inode_no */
- ii = inodetree_find(ip->i_di.di_num.no_addr);
- if (!ii)
- ii = inodetree_insert(ip->i_di.di_num);
+ ii = inodetree_find(ip->i_addr);
+ if (!ii) {
+ struct gfs2_inum no = {
+ .no_addr = ip->i_addr,
+ .no_formal_ino = ip->i_formal_ino
+ };
+ ii = inodetree_insert(no);
+ }
if (ii)
- ii->di_nlink = ip->i_di.di_nlink;
+ ii->di_nlink = ip->i_nlink;
else
return -1;
return 0;
@@ -81,7 +85,7 @@ int incr_link_count(struct gfs2_inum no, struct gfs2_inode *ip,
const char *why)
{
struct inode_info *ii = NULL;
- uint64_t referenced_from = ip ? ip->i_di.di_num.no_addr : 0;
+ uint64_t referenced_from = ip ? ip->i_addr : 0;
struct dir_info *di;
struct gfs2_inode *link_ip;
@@ -112,7 +116,7 @@ int incr_link_count(struct gfs2_inum no, struct gfs2_inode *ip,
link_ip = fsck_load_inode(ip->i_sbd, no.no_addr);
/* Check formal ino against dinode before adding to inode tree. */
- if (no.no_formal_ino != link_ip->i_di.di_num.no_formal_ino) {
+ if (no.no_formal_ino != link_ip->i_formal_ino) {
fsck_inode_put(&link_ip);
return INCR_LINK_INO_MISMATCH; /* inode mismatch */
}
@@ -132,7 +136,8 @@ int incr_link_count(struct gfs2_inum no, struct gfs2_inode *ip,
fsck_inode_put(&link_ip);
return INCR_LINK_BAD;
}
- ii->di_num = link_ip->i_di.di_num;
+ ii->di_num.no_addr = link_ip->i_addr;
+ ii->di_num.no_formal_ino = link_ip->i_formal_ino;
fsck_inode_put(&link_ip);
ii->di_nlink = 1; /* Must be 1 or it wouldn't have gotten into the
nlink1map */
diff --git a/gfs2/fsck/lost_n_found.c b/gfs2/fsck/lost_n_found.c
index ebe616af..59df4c05 100644
--- a/gfs2/fsck/lost_n_found.c
+++ b/gfs2/fsck/lost_n_found.c
@@ -20,43 +20,38 @@
static void add_dotdot(struct gfs2_inode *ip)
{
- struct dir_info *di;
struct gfs2_sbd *sdp = ip->i_sbd;
+ struct dir_info *di;
+ struct gfs2_inum no;
int err;
- log_info( _("Adding .. entry to directory %llu (0x%llx) pointing back "
- "to lost+found\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_info(_("Adding .. entry to directory %"PRIu64" (0x%"PRIx64") pointing back to lost+found\n"),
+ ip->i_addr, ip->i_addr);
/* If there's a pre-existing .. directory entry, we have to
back out the links. */
- di = dirtree_find(ip->i_di.di_num.no_addr);
+ di = dirtree_find(ip->i_addr);
if (di && valid_block(sdp, di->dotdot_parent.no_addr)) {
struct gfs2_inode *dip;
- log_debug(_("Directory (0x%llx) already had a "
- "\"..\" link to (0x%llx).\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)di->dotdot_parent.no_addr);
+ log_debug(_("Directory (0x%"PRIx64") already had a '..' link to (0x%"PRIx64").\n"),
+ ip->i_addr, di->dotdot_parent.no_addr);
dip = fsck_load_inode(sdp, di->dotdot_parent.no_addr);
- if (dip->i_di.di_num.no_formal_ino ==
- di->dotdot_parent.no_formal_ino) {
- decr_link_count(di->dotdot_parent.no_addr,
- ip->i_di.di_num.no_addr, sdp->gfs1,
+ if (dip->i_formal_ino == di->dotdot_parent.no_formal_ino) {
+ decr_link_count(di->dotdot_parent.no_addr, ip->i_addr, sdp->gfs1,
_(".. unlinked, moving to lost+found"));
- if (dip->i_di.di_nlink > 0) {
- dip->i_di.di_nlink--;
+ if (dip->i_nlink > 0) {
+ dip->i_nlink--;
set_di_nlink(dip); /* keep inode tree in sync */
log_debug(_("Decrementing its links to %d\n"),
- dip->i_di.di_nlink);
+ dip->i_nlink);
bmodified(dip->i_bh);
- } else if (!dip->i_di.di_nlink) {
+ } else if (!dip->i_nlink) {
log_debug(_("Its link count is zero.\n"));
} else {
- log_debug(_("Its link count is %d! Changing "
- "it to 0.\n"), dip->i_di.di_nlink);
- dip->i_di.di_nlink = 0;
+ log_debug(_("Its link count is %d! Changing it to 0.\n"),
+ dip->i_nlink);
+ dip->i_nlink = 0;
set_di_nlink(dip); /* keep inode tree in sync */
bmodified(dip->i_bh);
}
@@ -64,32 +59,31 @@ static void add_dotdot(struct gfs2_inode *ip)
log_debug(_("Directory (0x%"PRIx64")'s link to parent "
"(0x%"PRIx64") had a formal inode discrepancy: "
"was 0x%"PRIx64", expected 0x%"PRIx64"\n"),
- ip->i_di.di_num.no_addr,
- di->dotdot_parent.no_addr,
+ ip->i_addr, di->dotdot_parent.no_addr,
di->dotdot_parent.no_formal_ino,
- dip->i_di.di_num.no_formal_ino);
+ dip->i_formal_ino);
log_debug(_("The parent directory was not changed.\n"));
}
fsck_inode_put(&dip);
di = NULL;
} else {
if (di)
- log_debug(_("Couldn't find a valid \"..\" entry "
- "for orphan directory (0x%llx): "
- "'..' = 0x%llx\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)di->dotdot_parent.no_addr);
+ log_debug(_("Couldn't find a valid '..' entry "
+ "for orphan directory (0x%"PRIx64"): "
+ "'..' = 0x%"PRIx64"\n"),
+ ip->i_addr, di->dotdot_parent.no_addr);
else
- log_debug(_("Couldn't find directory (0x%llx) "
+ log_debug(_("Couldn't find directory (0x%"PRIx64") "
"in directory tree.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr);
+ ip->i_addr);
}
if (gfs2_dirent_del(ip, "..", 2))
log_warn( _("add_inode_to_lf: Unable to remove "
"\"..\" directory entry.\n"));
- err = dir_add(ip, "..", 2, &(lf_dip->i_di.di_num),
- (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR));
+ no.no_addr = lf_dip->i_addr;
+ no.no_formal_ino = lf_dip->i_formal_ino;
+ err = dir_add(ip, "..", 2, &no, (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR));
if (err) {
log_crit(_("Error adding .. directory: %s\n"),
strerror(errno));
@@ -107,7 +101,7 @@ void make_sure_lf_exists(struct gfs2_inode *ip)
if (lf_dip)
return;
- root_entries = sdp->md.rooti->i_di.di_entries;
+ root_entries = sdp->md.rooti->i_entries;
log_info( _("Locating/Creating lost+found directory\n"));
/* if this is gfs1, we have to trick createi into using
@@ -132,32 +126,38 @@ void make_sure_lf_exists(struct gfs2_inode *ip)
them in sync so that pass4 can detect and fix any descrepancies. */
set_di_nlink(sdp->md.rooti);
- if (sdp->md.rooti->i_di.di_entries > root_entries) {
+ if (sdp->md.rooti->i_entries > root_entries) {
+ struct gfs2_inum no = {
+ .no_addr = lf_dip->i_addr,
+ .no_formal_ino = lf_dip->i_formal_ino
+ };
lf_was_created = 1;
/* This is a new lost+found directory, so set its block type
and increment link counts for the directories */
/* FIXME: i'd feel better about this if fs_mkdir returned
whether it created a new directory or just found an old one,
and we used that instead of the bitmap_type to run this */
- dirtree_insert(lf_dip->i_di.di_num);
+ dirtree_insert(no);
/* Set the bitmap AFTER the dirtree insert so that function
check_n_fix_bitmap will realize it's a dinode and adjust
the rgrp counts properly. */
- fsck_bitmap_set(ip, lf_dip->i_di.di_num.no_addr,
- _("lost+found dinode"), GFS2_BLKST_DINODE);
+ fsck_bitmap_set(ip, lf_dip->i_addr, _("lost+found dinode"), GFS2_BLKST_DINODE);
/* root inode links to lost+found */
- incr_link_count(sdp->md.rooti->i_di.di_num, lf_dip, _("root"));
+ no.no_addr = sdp->md.rooti->i_addr;
+ no.no_formal_ino = sdp->md.rooti->i_formal_ino;
+ incr_link_count(no, lf_dip, _("root"));
/* lost+found link for '.' from itself */
- incr_link_count(lf_dip->i_di.di_num, lf_dip, "\".\"");
+ no.no_addr = lf_dip->i_addr;
+ no.no_formal_ino = lf_dip->i_formal_ino;
+ incr_link_count(no, lf_dip, "\".\"");
/* lost+found link for '..' back to root */
- incr_link_count(lf_dip->i_di.di_num, sdp->md.rooti, "\"..\"");
+ incr_link_count(no, sdp->md.rooti, "\"..\"");
if (sdp->gfs1)
- lf_dip->i_di.__pad1 = GFS_FILE_DIR;
+ lf_dip->i_pad1 = GFS_FILE_DIR;
}
- log_info( _("lost+found directory is dinode %lld (0x%llx)\n"),
- (unsigned long long)lf_dip->i_di.di_num.no_addr,
- (unsigned long long)lf_dip->i_di.di_num.no_addr);
- di = dirtree_find(lf_dip->i_di.di_num.no_addr);
+ log_info(_("lost+found directory is dinode %"PRIu64" (0x%"PRIx64")\n"),
+ lf_dip->i_addr, lf_dip->i_addr);
+ di = dirtree_find(lf_dip->i_addr);
if (di) {
log_info( _("Marking lost+found inode connected\n"));
di->checked = 1;
@@ -178,11 +178,12 @@ int add_inode_to_lf(struct gfs2_inode *ip){
char tmp_name[256];
__be32 inode_type;
struct gfs2_sbd *sdp = ip->i_sbd;
+ struct gfs2_inum no;
int err = 0;
uint32_t mode;
make_sure_lf_exists(ip);
- if (ip->i_di.di_num.no_addr == lf_dip->i_di.di_num.no_addr) {
+ if (ip->i_addr == lf_dip->i_addr) {
log_err( _("Trying to add lost+found to itself...skipping"));
return 0;
}
@@ -190,54 +191,47 @@ int add_inode_to_lf(struct gfs2_inode *ip){
if (sdp->gfs1)
mode = gfs_to_gfs2_mode(ip);
else
- mode = ip->i_di.di_mode & S_IFMT;
+ mode = ip->i_mode & S_IFMT;
switch (mode) {
case S_IFDIR:
add_dotdot(ip);
- sprintf(tmp_name, "lost_dir_%llu",
- (unsigned long long)ip->i_di.di_num.no_addr);
+ sprintf(tmp_name, "lost_dir_%"PRIu64, ip->i_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR);
break;
case S_IFREG:
- sprintf(tmp_name, "lost_file_%llu",
- (unsigned long long)ip->i_di.di_num.no_addr);
+ sprintf(tmp_name, "lost_file_%"PRIu64, ip->i_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_REG : DT_REG);
break;
case S_IFLNK:
- sprintf(tmp_name, "lost_link_%llu",
- (unsigned long long)ip->i_di.di_num.no_addr);
+ sprintf(tmp_name, "lost_link_%"PRIu64, ip->i_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_LNK : DT_LNK);
break;
case S_IFBLK:
- sprintf(tmp_name, "lost_blkdev_%llu",
- (unsigned long long)ip->i_di.di_num.no_addr);
+ sprintf(tmp_name, "lost_blkdev_%"PRIu64, ip->i_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_BLK : DT_BLK);
break;
case S_IFCHR:
- sprintf(tmp_name, "lost_chrdev_%llu",
- (unsigned long long)ip->i_di.di_num.no_addr);
+ sprintf(tmp_name, "lost_chrdev_%"PRIu64, ip->i_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_CHR : DT_CHR);
break;
case S_IFIFO:
- sprintf(tmp_name, "lost_fifo_%llu",
- (unsigned long long)ip->i_di.di_num.no_addr);
+ sprintf(tmp_name, "lost_fifo_%"PRIu64, ip->i_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_FIFO : DT_FIFO);
break;
case S_IFSOCK:
- sprintf(tmp_name, "lost_socket_%llu",
- (unsigned long long)ip->i_di.di_num.no_addr);
+ sprintf(tmp_name, "lost_socket_%"PRIu64, ip->i_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_SOCK : DT_SOCK);
break;
default:
- sprintf(tmp_name, "lost_%llu",
- (unsigned long long)ip->i_di.di_num.no_addr);
+ sprintf(tmp_name, "lost_%"PRIu64, ip->i_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_REG : DT_REG);
break;
}
- err = dir_add(lf_dip, tmp_name, strlen(tmp_name), &(ip->i_di.di_num),
- inode_type);
+ no.no_addr = ip->i_addr;
+ no.no_formal_ino = ip->i_formal_ino;
+ err = dir_add(lf_dip, tmp_name, strlen(tmp_name), &no, inode_type);
if (err) {
log_crit(_("Error adding directory %s: %s\n"),
tmp_name, strerror(errno));
@@ -245,15 +239,16 @@ int add_inode_to_lf(struct gfs2_inode *ip){
}
/* This inode is linked from lost+found */
- incr_link_count(ip->i_di.di_num, lf_dip, _("from lost+found"));
+ incr_link_count(no, lf_dip, _("from lost+found"));
/* If it's a directory, lost+found is back-linked to it via .. */
- if (mode == S_IFDIR)
- incr_link_count(lf_dip->i_di.di_num, ip, _("to lost+found"));
-
- log_notice( _("Added inode #%llu (0x%llx) to lost+found\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
- gfs2_dinode_out(&lf_dip->i_di, lf_dip->i_bh->b_data);
+ if (mode == S_IFDIR) {
+ no.no_addr = lf_dip->i_addr;
+ no.no_formal_ino = lf_dip->i_formal_ino;
+ incr_link_count(no, ip, _("to lost+found"));
+ }
+ log_notice(_("Added inode #%"PRIu64" (0x%"PRIx64") to lost+found\n"),
+ ip->i_addr, ip->i_addr);
+ lgfs2_dinode_out(lf_dip, lf_dip->i_bh->b_data);
bwrite(lf_dip->i_bh);
return 0;
}
diff --git a/gfs2/fsck/main.c b/gfs2/fsck/main.c
index d424e075..e322b395 100644
--- a/gfs2/fsck/main.c
+++ b/gfs2/fsck/main.c
@@ -174,16 +174,15 @@ static int check_statfs(struct gfs2_sbd *sdp)
uint64_t sc_dinodes;
int count;
- if (sdp->gfs1 && !sdp->md.statfs->i_di.di_size) {
+ if (sdp->gfs1 && !sdp->md.statfs->i_size) {
log_info("This GFS1 file system is not using fast_statfs.\n");
return 0;
}
/* Read the current statfs values */
- count = gfs2_readi(sdp->md.statfs, &sc, 0,
- sdp->md.statfs->i_di.di_size);
+ count = gfs2_readi(sdp->md.statfs, &sc, 0, sdp->md.statfs->i_size);
if (count != sizeof(struct gfs2_statfs_change)) {
log_err(_("Failed to read statfs values (%d of %"PRIu64" read)\n"),
- count, (uint64_t)sdp->md.statfs->i_di.di_size);
+ count, sdp->md.statfs->i_size);
return FSCK_ERROR;
}
sc_total = be64_to_cpu(sc.sc_total);
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 8b721015..991f1175 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -178,9 +178,9 @@ int _fsck_bitmap_set(struct gfs2_inode *ip, uint64_t bblock,
static const char *prev_caller = NULL;
if (print_level >= MSG_DEBUG) {
- if ((ip->i_di.di_num.no_addr == prev_ino_addr) &&
+ if ((ip->i_addr == prev_ino_addr) &&
(mark == prev_mark) && caller == prev_caller) {
- log_info("(0x%llx) ", (unsigned long long)bblock);
+ log_info("(0x%"PRIx64") ", bblock);
prevcount++;
if (prevcount > 10) {
log_info("\n");
@@ -188,30 +188,23 @@ int _fsck_bitmap_set(struct gfs2_inode *ip, uint64_t bblock,
}
/* I'm circumventing the log levels here on purpose to make the
output easier to debug. */
- } else if (ip->i_di.di_num.no_addr == bblock) {
+ } else if (ip->i_addr == bblock) {
if (prevcount) {
log_info("\n");
prevcount = 0;
}
- printf( _("(%s:%d) %s inode found at block "
- "(0x%llx): marking as '%s'\n"), caller, fline,
- btype,
- (unsigned long long)ip->i_di.di_num.no_addr,
- block_type_string(mark));
-
+ printf(_("(%s:%d) %s inode found at block (0x%"PRIx64"): marking as '%s'\n"),
+ caller, fline, btype, ip->i_addr, block_type_string(mark));
} else {
if (prevcount) {
log_info("\n");
prevcount = 0;
}
- printf( _("(%s:%d) inode (0x%llx) references %s block"
- " (0x%llx): marking as '%s'\n"),
- caller, fline,
- (unsigned long long)ip->i_di.di_num.no_addr,
- btype, (unsigned long long)bblock,
- block_type_string(mark));
+ printf(_("(%s:%d) inode (0x%"PRIx64") references %s block"
+ " (0x%"PRIx64"): marking as '%s'\n"),
+ caller, fline, ip->i_addr, btype, bblock, block_type_string(mark));
}
- prev_ino_addr = ip->i_di.di_num.no_addr;
+ prev_ino_addr = ip->i_addr;
prev_mark = mark;
prev_caller = caller;
}
@@ -243,24 +236,24 @@ struct gfs2_inode *fsck_system_inode(struct gfs2_sbd *sdp, uint64_t block)
{
int j;
- if (lf_dip && lf_dip->i_di.di_num.no_addr == block)
+ if (lf_dip && lf_dip->i_addr == block)
return lf_dip;
if (!sdp->gfs1)
return is_system_inode(sdp, block);
- if (sdp->md.statfs && block == sdp->md.statfs->i_di.di_num.no_addr)
+ if (sdp->md.statfs && block == sdp->md.statfs->i_addr)
return sdp->md.statfs;
- if (sdp->md.jiinode && block == sdp->md.jiinode->i_di.di_num.no_addr)
+ if (sdp->md.jiinode && block == sdp->md.jiinode->i_addr)
return sdp->md.jiinode;
- if (sdp->md.riinode && block == sdp->md.riinode->i_di.di_num.no_addr)
+ if (sdp->md.riinode && block == sdp->md.riinode->i_addr)
return sdp->md.riinode;
- if (sdp->md.qinode && block == sdp->md.qinode->i_di.di_num.no_addr)
+ if (sdp->md.qinode && block == sdp->md.qinode->i_addr)
return sdp->md.qinode;
- if (sdp->md.rooti && block == sdp->md.rooti->i_di.di_num.no_addr)
+ if (sdp->md.rooti && block == sdp->md.rooti->i_addr)
return sdp->md.rooti;
for (j = 0; j < sdp->md.journals; j++)
if (sdp->md.journal && sdp->md.journal[j] &&
- block == sdp->md.journal[j]->i_di.di_num.no_addr)
+ block == sdp->md.journal[j]->i_addr)
return sdp->md.journal[j];
return NULL;
}
@@ -307,7 +300,7 @@ void fsck_inode_put(struct gfs2_inode **ip_in)
struct gfs2_inode *ip = *ip_in;
struct gfs2_inode *sysip;
- sysip = fsck_system_inode(ip->i_sbd, ip->i_di.di_num.no_addr);
+ sysip = fsck_system_inode(ip->i_sbd, ip->i_addr);
if (!sysip)
inode_put(ip_in);
}
@@ -430,14 +423,11 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
if (de.de_rec_len < sizeof(struct gfs2_dirent) +
de.de_name_len ||
(de.de_inum.no_formal_ino && !de.de_name_len && !first)) {
- log_err( _("Directory block %llu (0x%llx"
- "), entry %d of directory %llu "
- "(0x%llx) is corrupt.\n"),
- (unsigned long long)bh->b_blocknr,
- (unsigned long long)bh->b_blocknr,
- (*count) + 1,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Directory block %"PRIu64" (0x%"PRIx64"), "
+ "entry %d of directory %"PRIu64" (0x%"PRIx64") "
+ "is corrupt.\n"),
+ bh->b_blocknr, bh->b_blocknr, (*count) + 1,
+ ip->i_addr, ip->i_addr);
if (query( _("Attempt to repair it? (y/n) "))) {
if (dirent_repair(ip, bh, &de, dent, type,
first)) {
@@ -467,13 +457,11 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
log_debug( _("First dirent is a sentinel (place holder).\n"));
first = 0;
} else {
- log_err( _("Directory entry with inode number of "
- "zero in leaf %llu (0x%llx) of "
- "directory %llu (0x%llx)!\n"),
- (unsigned long long)bh->b_blocknr,
- (unsigned long long)bh->b_blocknr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Directory entry with inode number of "
+ "zero in leaf %"PRIu64" (0x%"PRIx64") of "
+ "directory %"PRIu64" (0x%"PRIx64")!\n"),
+ bh->b_blocknr, bh->b_blocknr,
+ ip->i_addr, ip->i_addr);
if (query(_("Attempt to remove it? (y/n) "))) {
dirblk_truncate(ip, prev, bh);
log_err(_("The corrupt directory "
@@ -509,13 +497,10 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
}
if ((char *)dent + de.de_rec_len >= bh_end){
- log_debug( _("Last entry processed for %lld->%lld "
- "(0x%llx->0x%llx), di_blocks=%llu.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)bh->b_blocknr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)bh->b_blocknr,
- (unsigned long long)ip->i_di.di_blocks);
+ log_debug(_("Last entry processed for %"PRIu64"->%"PRIu64
+ "(0x%"PRIx64"->0x%"PRIx64"), di_blocks=%"PRIu64".\n"),
+ ip->i_addr, bh->b_blocknr, ip->i_addr,
+ bh->b_blocknr, ip->i_blocks);
break;
}
@@ -542,16 +527,13 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass,
uint32_t count = 0;
struct gfs2_sbd *sdp = ip->i_sbd;
const char *msg;
- int di_depth = ip->i_di.di_depth;
+ int di_depth = ip->i_depth;
/* Make sure the block number is in range. */
if (!valid_block_ip(ip, *leaf_no)) {
- log_err( _("Leaf block #%llu (0x%llx) is out of range for "
- "directory #%llu (0x%llx) at index %d (0x%x).\n"),
- (unsigned long long)*leaf_no,
- (unsigned long long)*leaf_no,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
+ log_err( _("Leaf block #%"PRIu64" (0x%"PRIx64") is out of range for "
+ "directory #%"PRIu64" (0x%"PRIx64") at index %d (0x%x).\n"),
+ *leaf_no, *leaf_no, ip->i_addr, ip->i_addr,
lindex, lindex);
msg = _("that is out of range");
goto bad_leaf;
@@ -595,17 +577,14 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass,
/* Make sure it's really a leaf. */
if (leaf->lf_header.mh_type != GFS2_METATYPE_LF) {
- log_err( _("Inode %llu (0x%llx) points to bad leaf %llu"
- " (0x%llx).\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)*leaf_no,
- (unsigned long long)*leaf_no);
+ log_err(_("Inode %"PRIu64" (0x%"PRIx64") points to bad leaf %"PRIu64
+ " (0x%"PRIx64").\n"),
+ ip->i_addr, ip->i_addr, *leaf_no, *leaf_no);
msg = _("that is not a leaf");
goto bad_leaf;
}
- if (pass->check_dentry && is_dir(&ip->i_di, sdp->gfs1)) {
+ if (pass->check_dentry && is_dir(ip, sdp->gfs1)) {
error = check_entries(ip, lbh, DIR_EXHASH, &count, lindex,
pass);
@@ -626,14 +605,11 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass,
lbh = bread(sdp, *leaf_no);
gfs2_leaf_in(leaf, lbh->b_data);
if (count != leaf->lf_entries) {
- log_err( _("Leaf %llu (0x%llx) entry count in "
- "directory %llu (0x%llx) does not match "
+ log_err(_("Leaf %"PRIu64" (0x%"PRIx64") entry count in "
+ "directory %"PRIu64" (0x%"PRIx64") does not match "
"number of entries found - is %u, found %u\n"),
- (unsigned long long)*leaf_no,
- (unsigned long long)*leaf_no,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- leaf->lf_entries, count);
+ *leaf_no, *leaf_no, ip->i_addr, ip->i_addr,
+ leaf->lf_entries, count);
if (query( _("Update leaf entry count? (y/n) "))) {
leaf->lf_entries = count;
gfs2_leaf_out(leaf, lbh->b_data);
@@ -645,15 +621,12 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass,
}
}
out:
- if (di_depth < ip->i_di.di_depth) {
- log_debug(_("Depth of directory %lld (0x%llx) changed from "
+ if (di_depth < ip->i_depth) {
+ log_debug(_("Depth of directory %"PRIu64" (0x%"PRIx64") changed from "
"%d to %d; adjusting ref_count from %d to %d\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- di_depth, ip->i_di.di_depth,
- *ref_count,
- (*ref_count) << (ip->i_di.di_depth - di_depth));
- (*ref_count) <<= (ip->i_di.di_depth - di_depth);
+ ip->i_addr, ip->i_addr, di_depth, ip->i_depth,
+ *ref_count, (*ref_count) << (ip->i_depth - di_depth));
+ (*ref_count) <<= (ip->i_depth - di_depth);
}
brelse(lbh);
if (error < 0)
@@ -670,15 +643,12 @@ bad_leaf:
return fix;
}
- if (di_depth < ip->i_di.di_depth) {
- log_debug(_("Depth of directory %lld (0x%llx) changed from "
+ if (di_depth < ip->i_depth) {
+ log_debug(_("Depth of directory %"PRIu64" (0x%"PRIx64") changed from "
"%d to %d. Adjusting ref_count from %d to %d\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- di_depth, ip->i_di.di_depth,
- *ref_count,
- (*ref_count) << (ip->i_di.di_depth - di_depth));
- (*ref_count) <<= (ip->i_di.di_depth - di_depth);
+ ip->i_addr, ip->i_addr, di_depth, ip->i_depth,
+ *ref_count, (*ref_count) << (ip->i_depth - di_depth));
+ (*ref_count) <<= (ip->i_depth - di_depth);
}
return 1;
}
@@ -718,7 +688,7 @@ static void dir_leaf_reada(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize)
int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
{
int error = 0;
- unsigned hsize = (1 << ip->i_di.di_depth);
+ unsigned hsize = (1 << ip->i_depth);
uint64_t leaf_no, leaf_next;
uint64_t first_ok_leaf, orig_di_blocks;
struct gfs2_buffer_head *lbh;
@@ -734,9 +704,9 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
return -1;
}
tbl_valid = 1;
- orig_di_depth = ip->i_di.di_depth;
- orig_di_height = ip->i_di.di_height;
- orig_di_blocks = ip->i_di.di_blocks;
+ orig_di_depth = ip->i_depth;
+ orig_di_height = ip->i_height;
+ orig_di_blocks = ip->i_blocks;
/* Turn off system readahead */
posix_fadvise(sdp->device_fd, 0, 0, POSIX_FADV_RANDOM);
@@ -780,10 +750,8 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
}
}
if (first_ok_leaf == -1) { /* no valid leaf found */
- log_err( _("Directory #%llu (0x%llx) has no valid leaf "
- "blocks\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Directory #%"PRIu64" (0x%"PRIx64") has no valid leaf blocks\n"),
+ ip->i_addr, ip->i_addr);
free(tbl);
posix_fadvise(sdp->device_fd, 0, 0, POSIX_FADV_NORMAL);
return 1;
@@ -798,17 +766,16 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
if (!tbl_valid) {
free(tbl);
- log_debug(_("Re-reading 0x%llx hash table.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_debug(_("Re-reading 0x%"PRIx64" hash table.\n"), ip->i_addr);
tbl = get_dir_hash(ip);
if (tbl == NULL) {
perror("get_dir_hash");
return -1;
}
tbl_valid = 1;
- orig_di_depth = ip->i_di.di_depth;
- orig_di_height = ip->i_di.di_height;
- orig_di_blocks = ip->i_di.di_blocks;
+ orig_di_depth = ip->i_depth;
+ orig_di_height = ip->i_height;
+ orig_di_blocks = ip->i_blocks;
}
leaf_no = be64_to_cpu(tbl[lindex]);
@@ -853,27 +820,21 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
log_debug( _("Leaf chain #%d (0x%llx) detected.\n"),
chained_leaf, (unsigned long long)leaf_no);
} while (1); /* while we have chained leaf blocks */
- if (orig_di_depth != ip->i_di.di_depth) {
- log_debug(_("Depth of 0x%llx changed from %d to %d\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- orig_di_depth, ip->i_di.di_depth);
+ if (orig_di_depth != ip->i_depth) {
+ log_debug(_("Depth of 0x%"PRIx64" changed from %d to %d\n"),
+ ip->i_addr, orig_di_depth, ip->i_depth);
tbl_valid = 0;
- lindex <<= (ip->i_di.di_depth - orig_di_depth);
- hsize = (1 << ip->i_di.di_depth);
+ lindex <<= (ip->i_depth - orig_di_depth);
+ hsize = (1 << ip->i_depth);
}
- if (orig_di_height != ip->i_di.di_height) {
- log_debug(_("Height of 0x%llx changed from %d to "
- "%d\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- orig_di_height, ip->i_di.di_height);
+ if (orig_di_height != ip->i_height) {
+ log_debug(_("Height of 0x%"PRIx64" changed from %d to %d\n"),
+ ip->i_addr, orig_di_height, ip->i_height);
tbl_valid = 0;
}
- if (orig_di_blocks != ip->i_di.di_blocks) {
- log_debug(_("Block count of 0x%llx changed from %llu "
- "to %llu\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)orig_di_blocks,
- (unsigned long long)ip->i_di.di_blocks);
+ if (orig_di_blocks != ip->i_blocks) {
+ log_debug(_("Block count of 0x%"PRIx64" changed from %"PRIu64" to %"PRIu64"\n"),
+ ip->i_addr, orig_di_blocks, ip->i_blocks);
tbl_valid = 0;
}
lindex += ref_count;
@@ -967,12 +928,9 @@ static int check_leaf_eattr(struct gfs2_inode *ip, uint64_t block,
if (pass->check_eattr_leaf) {
int error = 0;
- log_debug( _("Checking EA leaf block #%llu (0x%llx) for "
- "inode #%llu (0x%llx).\n"),
- (unsigned long long)block,
- (unsigned long long)block,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_debug(_("Checking EA leaf block #%"PRIu64" (0x%"PRIx64") for "
+ "inode #%"PRIu64" (0x%"PRIx64").\n"),
+ block, block, ip->i_addr, ip->i_addr);
error = pass->check_eattr_leaf(ip, block, parent, &bh,
pass->private);
@@ -1011,7 +969,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect,
uint64_t block;
struct gfs2_sbd *sdp = ip->i_sbd;
int first_ea_is_bad = 0;
- uint64_t di_eattr_save = ip->i_di.di_eattr;
+ uint64_t di_eattr_save = ip->i_eattr;
uint64_t offset = ip->i_sbd->gfs1 ? sizeof(struct gfs_indirect) : sizeof(struct gfs2_meta_header);
int leaf_pointers = 0, leaf_pointer_errors = 0;
@@ -1064,7 +1022,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect,
check_leaf_eattr to delete all eattrs after the bad
one. So we want: GGGG when we finish. To do that,
we set di_eattr to 0 temporarily. */
- ip->i_di.di_eattr = 0;
+ ip->i_eattr = 0;
bmodified(ip->i_bh);
}
ea_leaf_ptr++;
@@ -1072,7 +1030,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect,
/* If we temporarily nuked the ea block to prevent checking past
a corrupt ea leaf, we need to restore the saved di_eattr block. */
if (di_eattr_save != 0)
- ip->i_di.di_eattr = di_eattr_save;
+ ip->i_eattr = di_eattr_save;
if (pass->finish_eattr_indir) {
if (!first_ea_is_bad) {
pass->finish_eattr_indir(ip, leaf_pointers,
@@ -1100,24 +1058,20 @@ int check_inode_eattr(struct gfs2_inode *ip, struct metawalk_fxns *pass)
int error = 0;
struct gfs2_buffer_head *indirect_buf = NULL;
- if (!ip->i_di.di_eattr)
+ if (!ip->i_eattr)
return 0;
- if (ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT){
+ if (ip->i_flags & GFS2_DIF_EA_INDIRECT){
if (!pass->check_eattr_indir)
return 0;
- log_debug( _("Checking EA indirect block #%llu (0x%llx) for "
- "inode #%llu (0x%llx)..\n"),
- (unsigned long long)ip->i_di.di_eattr,
- (unsigned long long)ip->i_di.di_eattr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
- error = pass->check_eattr_indir(ip, ip->i_di.di_eattr,
- ip->i_di.di_num.no_addr,
+ log_debug(_("Checking EA indirect block #%"PRIu64" (0x%"PRIx64") for "
+ "inode #%"PRIu64" (0x%"PRIx64")..\n"),
+ ip->i_eattr, ip->i_eattr, ip->i_addr, ip->i_addr);
+ error = pass->check_eattr_indir(ip, ip->i_eattr, ip->i_addr,
&indirect_buf, pass->private);
if (!error) {
- error = check_indirect_eattr(ip, ip->i_di.di_eattr,
+ error = check_indirect_eattr(ip, ip->i_eattr,
indirect_buf, pass);
if (error)
stack;
@@ -1126,8 +1080,7 @@ int check_inode_eattr(struct gfs2_inode *ip, struct metawalk_fxns *pass)
brelse(indirect_buf);
return error;
}
- error = check_leaf_eattr(ip, ip->i_di.di_eattr,
- ip->i_di.di_num.no_addr, pass);
+ error = check_leaf_eattr(ip, ip->i_eattr, ip->i_addr, pass);
if (error)
stack;
@@ -1139,7 +1092,7 @@ int check_inode_eattr(struct gfs2_inode *ip, struct metawalk_fxns *pass)
*/
static void free_metalist(struct gfs2_inode *ip, osi_list_t *mlp)
{
- unsigned int height = ip->i_di.di_height;
+ unsigned int height = ip->i_height;
unsigned int i;
struct gfs2_buffer_head *nbh;
@@ -1165,7 +1118,7 @@ static void file_ra(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
uint64_t *p, sblock = 0, block;
int extlen = 0;
- if (h + 2 == ip->i_di.di_height) {
+ if (h + 2 == ip->i_height) {
p = (uint64_t *)(bh->b_data + head_size);
if (*p && *(p + 1)) {
sblock = be64_to_cpu(*p);
@@ -1272,7 +1225,7 @@ static int do_check_metalist(struct iptr iptr, int height, struct gfs2_buffer_he
static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
struct metawalk_fxns *pass)
{
- uint32_t height = ip->i_di.di_height;
+ uint32_t height = ip->i_height;
struct gfs2_buffer_head *metabh = ip->i_bh;
osi_list_t *prev_list, *cur_list, *tmp;
struct iptr iptr = { .ipt_ip = ip, 0};
@@ -1288,7 +1241,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
because it checks everything through the hash table using
"depth" field calculations. However, we still have to check the
indirect blocks, even if the height == 1. */
- if (is_dir(&ip->i_di, ip->i_sbd->gfs1))
+ if (is_dir(ip, ip->i_sbd->gfs1))
height++;
/* if (<there are no indirect blocks to check>) */
@@ -1296,8 +1249,8 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
return META_IS_GOOD;
for (h = 1; h < height; h++) {
if (h > 1) {
- if (is_dir(&ip->i_di, ip->i_sbd->gfs1) &&
- h == ip->i_di.di_height + 1)
+ if (is_dir(ip, ip->i_sbd->gfs1) &&
+ h == ip->i_height + 1)
iblk_type = GFS2_METATYPE_JD;
else
iblk_type = GFS2_METATYPE_IN;
@@ -1454,9 +1407,8 @@ static int metawalk_check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass
uint64_t metablock = bh->b_blocknr;
/* If there isn't much pointer corruption check the pointers */
- log_debug("Processing data blocks for inode 0x%llx, metadata block 0x%llx.\n",
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)metablock);
+ log_debug("Processing data blocks for inode 0x%"PRIx64", metadata block 0x%"PRIx64".\n",
+ ip->i_addr, metablock);
for (ptr = ptr_start ; ptr < ptr_end && !fsck_abort; ptr++) {
if (!*ptr)
continue;
@@ -1556,7 +1508,7 @@ static unsigned int should_check(struct gfs2_buffer_head *bh, unsigned int heigh
*/
int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass)
{
- unsigned int height = ip->i_di.di_height;
+ unsigned int height = ip->i_height;
osi_list_t *metalist = alloca((height + 1) * sizeof(*metalist));
osi_list_t *list, *tmp;
struct gfs2_buffer_head *bh;
@@ -1567,7 +1519,7 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass)
struct error_block error_blk = {0, 0, 0};
int hit_error_blk = 0;
- if (!height && !is_dir(&ip->i_di, ip->i_sbd->gfs1))
+ if (!height && !is_dir(ip, ip->i_sbd->gfs1))
return 0;
/* metalist has one extra element for directories (see build_and_check_metalist). */
@@ -1585,8 +1537,8 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass)
/* For directories, we've already checked the "data" blocks which
* comprise the directory hash table, so we perform the directory
* checks and exit. */
- if (is_dir(&ip->i_di, ip->i_sbd->gfs1)) {
- if (!(ip->i_di.di_flags & GFS2_DIF_EXHASH))
+ if (is_dir(ip, ip->i_sbd->gfs1)) {
+ if (!(ip->i_flags & GFS2_DIF_EXHASH))
goto out;
/* check validity of leaf blocks and leaf chains */
error = check_leaf_blks(ip, pass);
@@ -1597,7 +1549,7 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass)
/* check data blocks */
list = &metalist[height - 1];
- if (ip->i_di.di_blocks > COMFORTABLE_BLKS)
+ if (ip->i_blocks > COMFORTABLE_BLKS)
last_reported_fblock = -10000000;
for (tmp = list->next; !error && tmp != list; tmp = tmp->next) {
@@ -1612,30 +1564,24 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass)
if (pass->check_data)
error = metawalk_check_data(ip, pass, bh, height,
&blks_checked, &error_blk);
- if (pass->big_file_msg && ip->i_di.di_blocks > COMFORTABLE_BLKS)
+ if (pass->big_file_msg && ip->i_blocks > COMFORTABLE_BLKS)
pass->big_file_msg(ip, blks_checked);
}
- if (pass->big_file_msg && ip->i_di.di_blocks > COMFORTABLE_BLKS) {
- log_notice( _("\rLarge file at %lld (0x%llx) - 100 percent "
+ if (pass->big_file_msg && ip->i_blocks > COMFORTABLE_BLKS) {
+ log_notice( _("\rLarge file at %"PRIu64" (0x%"PRIx64") - 100 percent "
"complete. "
"\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ ip->i_addr, ip->i_addr);
fflush(stdout);
}
undo_metalist:
if (!error)
goto out;
- log_err( _("Error: inode %llu (0x%llx) had unrecoverable errors at "
- "metadata block %lld (0x%llx), offset %d (0x%x), block "
- "%lld (0x%llx).\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)error_blk.metablk,
- (unsigned long long)error_blk.metablk,
- error_blk.metaoff, error_blk.metaoff,
- (unsigned long long)error_blk.errblk,
- (unsigned long long)error_blk.errblk);
+ log_err(_("Error: inode %"PRIu64" (0x%"PRIx64") had unrecoverable errors at "
+ "metadata block %"PRIu64" (0x%"PRIx64"), offset %d (0x%x), block "
+ "%"PRIu64" (0x%"PRIx64").\n"),
+ ip->i_addr, ip->i_addr, error_blk.metablk, error_blk.metablk,
+ error_blk.metaoff, error_blk.metaoff, error_blk.errblk, error_blk.errblk);
if (!query( _("Remove the invalid inode? (y/n) "))) {
free_metalist(ip, metalist);
log_err(_("Invalid inode not deleted.\n"));
@@ -1668,10 +1614,9 @@ undo_metalist:
hit_error_blk = 1;
log_err("Reached the error "
"block undoing work "
- "for inode %lld "
- "(0x%llx).\n",
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ "for inode %"PRIu64" "
+ "(0x%"PRIx64").\n",
+ ip->i_addr, ip->i_addr);
rc = 0;
}
}
@@ -1688,8 +1633,7 @@ undo_metalist:
to undo. */
delete_all_dups(ip);
/* Set the dinode as "bad" so it gets deleted */
- fsck_bitmap_set(ip, ip->i_di.di_num.no_addr, "corrupt",
- GFS2_BLKST_FREE);
+ fsck_bitmap_set(ip, ip->i_addr, "corrupt", GFS2_BLKST_FREE);
log_err(_("The corrupt inode was invalidated.\n"));
out:
free_metalist(ip, metalist);
@@ -1716,7 +1660,7 @@ int check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip, struct metawalk_fxns
{
int error = 0;
- if (ip->i_di.di_flags & GFS2_DIF_EXHASH)
+ if (ip->i_flags & GFS2_DIF_EXHASH)
error = check_leaf_blks(ip, pass);
else
error = check_linear_dir(ip, ip->i_bh, pass);
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 0cd9b274..3454fd56 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -134,12 +134,8 @@ static int pass1_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no,
char *padbuf;
int pad_size, i;
- log_err( _("Directory Inode %llu (0x%llx) points to leaf %llu"
- " (0x%llx) %s.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)*leaf_no,
- (unsigned long long)*leaf_no, msg);
+ log_err(_("Directory Inode %"PRIu64" (0x%"PRIx64") points to leaf %"PRIu64" (0x%"PRIx64") %s.\n"),
+ ip->i_addr, ip->i_addr, *leaf_no, *leaf_no, msg);
if (!query( _("Attempt to patch around it? (y/n) "))) {
log_err( _("Bad leaf left in place.\n"));
goto out;
@@ -152,19 +148,16 @@ static int pass1_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no,
cpyptr++;
}
pad_size = ref_count * sizeof(uint64_t);
- log_err(_("Writing zeros to the hash table of directory %lld "
- "(0x%llx) at index: 0x%x for 0x%x pointers.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr, lindex,
- ref_count);
+ log_err(_("Writing zeros to the hash table of directory %"PRIu64
+ " (0x%"PRIx64") at index: 0x%x for 0x%x pointers.\n"),
+ ip->i_addr, ip->i_addr, lindex, ref_count);
if (ip->i_sbd->gfs1)
gfs1_writei(ip, padbuf, lindex * sizeof(uint64_t), pad_size);
else
gfs2_writei(ip, padbuf, lindex * sizeof(uint64_t), pad_size);
free(padbuf);
- log_err( _("Directory Inode %llu (0x%llx) patched.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Directory Inode %"PRIu64" (0x%"PRIx64") patched.\n"),
+ ip->i_addr, ip->i_addr);
out:
*leaf_no = 0;
@@ -207,12 +200,10 @@ static int resuscitate_metalist(struct iptr iptr, struct gfs2_buffer_head **bh,
*was_duplicate = 0;
*bh = NULL;
if (!valid_block_ip(ip, block)){ /* blk outside of FS */
- fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
- _("itself"), GFS2_BLKST_UNLINKED);
- log_err( _("Bad indirect block pointer (invalid or out of "
- "range) found in system inode %lld (0x%llx).\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ fsck_blockmap_set(ip, ip->i_addr, _("itself"), GFS2_BLKST_UNLINKED);
+ log_err(_("Bad indirect block pointer (invalid or out of "
+ "range) found in system inode %"PRIu64" (0x%"PRIx64").\n"),
+ ip->i_addr, ip->i_addr);
*is_valid = 0;
return META_IS_GOOD;
}
@@ -255,11 +246,9 @@ static int resuscitate_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
else
strncpy(tmp_name, filename, sizeof(tmp_name) - 1);
if (!valid_block_ip(ip, block)) {
- log_err( _("Block # referenced by system directory entry %s "
- "in inode %lld (0x%llx) is invalid or out of range;"
- " ignored.\n"),
- tmp_name, (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Block # referenced by system directory entry %s in inode "
+ "%"PRIu64" (0x%"PRIx64") is invalid or out of range; ignored.\n"),
+ tmp_name, ip->i_addr, ip->i_addr);
return 0;
}
/* If this is a system dinode, we'll handle it later in
@@ -296,14 +285,11 @@ static int p1check_leaf(struct gfs2_inode *ip, uint64_t block, void *private)
bc->indir_count++;
q = block_type(bl, block);
if (q != GFS2_BLKST_FREE) {
- log_err( _("Found duplicate block #%llu (0x%llx) referenced "
- "as a directory leaf in dinode "
- "%llu (0x%llx) - was marked %d (%s)\n"),
- (unsigned long long)block,
- (unsigned long long)block,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr, q,
- block_type_string(q));
+ log_err(_("Found duplicate block #%"PRIu64" (0x%"PRIx64") referenced "
+ "as a directory leaf in dinode "
+ "%"PRIu64" (0x%"PRIx64") - was marked %d (%s)\n"),
+ block, block, ip->i_addr, ip->i_addr, q,
+ block_type_string(q));
add_duplicate_ref(ip, block, REF_AS_META, 0, INODE_VALID);
if (q == (ip->i_sbd->gfs1 ? GFS2_BLKST_DINODE :
GFS2_BLKST_USED))
@@ -337,16 +323,15 @@ static int pass1_check_metalist(struct iptr iptr, struct gfs2_buffer_head **bh,
"unrecoverable" errors. The inode itself should be
set "free" and removed from the inodetree by
undo_check_metalist. */
- fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
+ fsck_blockmap_set(ip, ip->i_addr,
_("bad block referencing"), GFS2_BLKST_UNLINKED);
- log_debug( _("Bad indirect block (invalid/out of range) "
- "found in inode %lld (0x%llx).\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_debug(_("Bad indirect block (invalid/out of range) "
+ "found in inode %"PRIu64" (0x%"PRIx64").\n"),
+ ip->i_addr, ip->i_addr);
return META_SKIP_FURTHER;
}
- if (is_dir(&ip->i_di, ip->i_sbd->gfs1) && h == ip->i_di.di_height) {
+ if (is_dir(ip, ip->i_sbd->gfs1) && h == ip->i_height) {
iblk_type = GFS2_METATYPE_JD;
blktypedesc = _("a directory hash table block");
} else {
@@ -355,13 +340,10 @@ static int pass1_check_metalist(struct iptr iptr, struct gfs2_buffer_head **bh,
}
q = block_type(bl, block);
if (q != GFS2_BLKST_FREE) {
- log_err( _("Found duplicate block #%llu (0x%llx) referenced "
- "as metadata in indirect block for dinode "
- "%llu (0x%llx) - was marked %d (%s)\n"),
- (unsigned long long)block,
- (unsigned long long)block,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr, q,
+ log_err(_("Found duplicate block #%"PRIu64" (0x%"PRIx64") referenced "
+ "as metadata in indirect block for dinode "
+ "%"PRIu64" (0x%"PRIx64") - was marked %d (%s)\n"),
+ block, block, ip->i_addr, ip->i_addr, q,
block_type_string(q));
*was_duplicate = 1;
}
@@ -370,13 +352,10 @@ static int pass1_check_metalist(struct iptr iptr, struct gfs2_buffer_head **bh,
*is_valid = (gfs2_check_meta(nbh->b_data, iblk_type) == 0);
if (!(*is_valid)) {
- log_err( _("Inode %lld (0x%llx) has a bad indirect block "
- "pointer %lld (0x%llx) (points to something "
- "that is not %s).\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)block,
- (unsigned long long)block, blktypedesc);
+ log_err(_("Inode %"PRIu64" (0x%"PRIx64") has a bad indirect block "
+ "pointer %"PRIu64" (0x%"PRIx64") (points to something "
+ "that is not %s).\n"),
+ ip->i_addr, ip->i_addr, block, block, blktypedesc);
if (query(_("Zero the indirect block pointer? (y/n) "))){
*iptr_ptr(iptr) = 0;
bmodified(iptr.ipt_bh);
@@ -423,8 +402,7 @@ static int undo_reference(struct gfs2_inode *ip, uint64_t block, int meta,
struct rgrp_tree *rgd;
if (!valid_block_ip(ip, block)) { /* blk outside of FS */
- fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
- _("bad block referencing"), GFS2_BLKST_FREE);
+ fsck_blockmap_set(ip, ip->i_addr, _("bad block referencing"), GFS2_BLKST_FREE);
return 1;
}
@@ -509,12 +487,9 @@ static int blockmap_set_as_data(struct gfs2_inode *ip, uint64_t block)
if (be64_to_cpu(di->di_num.no_addr) != block)
goto out;
- log_err(_("Inode %lld (0x%llx) has a reference to block %lld (0x%llx) "
- "as a data block, but it appears to be a dinode we "
- "haven't checked yet.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)block, (unsigned long long)block);
+ log_err(_("Inode %"PRIu64" (0x%"PRIx64") has a reference to block %"PRIu64" (0x%"PRIx64") "
+ "as a data block, but it appears to be a dinode we haven't checked yet.\n"),
+ ip->i_addr, ip->i_addr, block, block);
error = -1;
out:
if (!error)
@@ -531,23 +506,18 @@ static int pass1_check_data(struct gfs2_inode *ip, uint64_t metablock,
struct block_count *bc = (struct block_count *) private;
if (!valid_block_ip(ip, block)) {
- log_err( _("inode %lld (0x%llx) has a bad data block pointer "
- "%lld (0x%llx) (invalid or out of range) "),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)block, (unsigned long long)block);
- if (metablock == ip->i_di.di_num.no_addr)
+ log_err(_("inode %"PRIu64" (0x%"PRIx64") has a bad data block pointer "
+ "%"PRIu64" (0x%"PRIx64") (invalid or out of range) "),
+ ip->i_addr, ip->i_addr, block, block);
+ if (metablock == ip->i_addr)
log_err("\n");
else
- log_err(_("from metadata block %llu (0x%llx)\n"),
- (unsigned long long)metablock,
- (unsigned long long)metablock);
+ log_err(_("from metadata block %"PRIu64" (0x%"PRIx64")\n"),
+ metablock, metablock);
/* Mark the owner of this block with the bad_block
* designator so we know to check it for out of range
* blocks later */
- fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
- _("bad (out of range) data"),
- GFS2_BLKST_UNLINKED);
+ fsck_blockmap_set(ip, ip->i_addr, _("bad (out of range) data"), GFS2_BLKST_UNLINKED);
return -1;
}
bc->data_count++; /* keep the count sane anyway */
@@ -556,14 +526,11 @@ static int pass1_check_data(struct gfs2_inode *ip, uint64_t metablock,
struct gfs2_buffer_head *bh;
struct gfs2_meta_header mh;
- log_err( _("Found duplicate %s block %llu (0x%llx) "
- "referenced as data by dinode %llu (0x%llx) "),
- block_type_string(q),
- (unsigned long long)block,
- (unsigned long long)block,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
- if (metablock == ip->i_di.di_num.no_addr)
+ log_err(_("Found duplicate %s block %"PRIu64" (0x%"PRIx64") "
+ "referenced as data by dinode %"PRIu64" (0x%"PRIx64") "),
+ block_type_string(q),
+ block, block, ip->i_addr, ip->i_addr);
+ if (metablock == ip->i_addr)
log_err("\n");
else
log_err(_("from metadata block %llu (0x%llx)\n"),
@@ -625,7 +592,7 @@ static int pass1_check_data(struct gfs2_inode *ip, uint64_t metablock,
gfs2_special_set(&gfs1_rindex_blks, block);
fsck_blockmap_set(ip, block, "rgrp", GFS2_BLKST_DINODE);
/*gfs2_meta_rgrp);*/
- } else if (ip->i_sbd->gfs1 && ip->i_di.di_flags & GFS2_DIF_JDATA) {
+ } else if (ip->i_sbd->gfs1 && ip->i_flags & GFS2_DIF_JDATA) {
log_info(_("Block %lld (0x%llx) is a GFS1 journaled data "
"block\n"),
(unsigned long long)block, (unsigned long long)block);
@@ -638,17 +605,16 @@ static int pass1_check_data(struct gfs2_inode *ip, uint64_t metablock,
static int ask_remove_inode_eattr(struct gfs2_inode *ip,
struct block_count *bc)
{
- if (ip->i_di.di_eattr == 0)
+ if (ip->i_eattr == 0)
return 0; /* eattr was removed prior to this call */
- log_err( _("Inode %lld (0x%llx) has unrecoverable Extended Attribute "
- "errors.\n"), (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Inode %"PRIu64" (0x%"PRIx64") has unrecoverable Extended Attribute errors.\n"),
+ ip->i_addr, ip->i_addr);
if (query( _("Clear all Extended Attributes from the inode? (y/n) "))){
- undo_reference(ip, ip->i_di.di_eattr, 0, bc);
- ip->i_di.di_eattr = 0;
+ undo_reference(ip, ip->i_eattr, 0, bc);
+ ip->i_eattr = 0;
bc->ea_count = 0;
- ip->i_di.di_blocks = 1 + bc->indir_count + bc->data_count;
- ip->i_di.di_flags &= ~GFS2_DIF_EA_INDIRECT;
+ ip->i_blocks = 1 + bc->indir_count + bc->data_count;
+ ip->i_flags &= ~GFS2_DIF_EA_INDIRECT;
bmodified(ip->i_bh);
log_err( _("Extended attributes were removed.\n"));
} else {
@@ -698,11 +664,8 @@ static int undo_eattr_indir_or_leaf(struct gfs2_inode *ip, uint64_t block,
static void complain_eas(struct gfs2_inode *ip, uint64_t block,
const char *emsg)
{
- log_err(_("Inode #%llu (0x%llx): %s"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr, emsg);
- log_err(_(" at block #%lld (0x%llx).\n"),
- (unsigned long long)block, (unsigned long long)block);
+ log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): %s"), ip->i_addr, ip->i_addr, emsg);
+ log_err(_(" at block #%"PRIu64" (0x%"PRIx64").\n"), block, block);
}
static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect,
@@ -769,25 +732,17 @@ static int finish_eattr_indir(struct gfs2_inode *ip, int leaf_pointers,
if (leaf_pointer_errors == leaf_pointers) /* All eas were bad */
return ask_remove_inode_eattr(ip, bc);
- log_debug( _("Marking inode #%llu (0x%llx) with extended "
- "attribute block\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_debug(_("Marking inode #%"PRIu64" (0x%"PRIx64") with extended attribute block\n"),
+ ip->i_addr, ip->i_addr);
if (!leaf_pointer_errors)
return 0;
- log_err( _("Inode %lld (0x%llx) has recoverable indirect "
- "Extended Attribute errors.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Inode %"PRIu64" (0x%"PRIx64") has recoverable indirect extended attribute errors.\n"),
+ ip->i_addr, ip->i_addr);
if (query( _("Okay to fix the block count for the inode? (y/n) "))) {
- ip->i_di.di_blocks = 1 + bc->indir_count +
- bc->data_count + bc->ea_count;
+ ip->i_blocks = 1 + bc->indir_count + bc->data_count + bc->ea_count;
bmodified(ip->i_bh);
- log_err(_("Block count fixed: 1+%lld+%lld+%lld = %lld.\n"),
- (unsigned long long)bc->indir_count,
- (unsigned long long)bc->data_count,
- (unsigned long long)bc->ea_count,
- (unsigned long long)ip->i_di.di_blocks);
+ log_err(_("Block count fixed: 1+%"PRIu64"+%"PRIu64"+%"PRIu64" = %"PRIu64".\n"),
+ bc->indir_count, bc->data_count, bc->ea_count, ip->i_blocks);
return 1;
}
log_err( _("Block count not fixed.\n"));
@@ -875,18 +830,12 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, int i,
int error = 0;
if (!valid_block_ip(ip, el_blk)) {
- log_err( _("Inode #%llu (0x%llx): Extended Attribute block "
- "%llu (0x%llx) has an extended leaf block #%llu "
- "(0x%llx) that is invalid or out of range.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_eattr,
- (unsigned long long)ip->i_di.di_eattr,
- (unsigned long long)el_blk,
- (unsigned long long)el_blk);
- fsck_blockmap_set(ip, ip->i_di.di_eattr,
- _("bad (out of range) Extended Attribute "),
- GFS2_BLKST_UNLINKED);
+ log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): extended attribute block "
+ "%"PRIu64" (0x%"PRIx64") has an extended leaf block #%"PRIu64" "
+ "(0x%"PRIx64") that is invalid or out of range.\n"),
+ ip->i_addr, ip->i_addr, ip->i_eattr, ip->i_eattr, el_blk, el_blk);
+ fsck_blockmap_set(ip, ip->i_eattr, _("bad (out of range) Extended Attribute "),
+ GFS2_BLKST_UNLINKED);
error = 1;
} else {
error = check_ealeaf_block(ip, el_blk, GFS2_METATYPE_ED, &bh,
@@ -906,7 +855,7 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, int i,
bmodified(leaf_bh);
/* Endianness doesn't matter in this case because it's
a single byte. */
- fsck_blockmap_set(ip, ip->i_di.di_eattr,
+ fsck_blockmap_set(ip, ip->i_eattr,
_("extended attribute"),
sdp->gfs1 ? GFS2_BLKST_DINODE :
GFS2_BLKST_USED);
@@ -925,15 +874,12 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
void *private)
{
if (!valid_block_ip(ip, block)) {
- log_warn( _("Inode #%llu (0x%llx): Extended Attribute leaf "
- "block #%llu (0x%llx) is invalid or out of "
- "range.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)block, (unsigned long long)block);
- fsck_blockmap_set(ip, ip->i_di.di_eattr,
- _("bad (out of range) Extended "
- "Attribute leaf"), GFS2_BLKST_UNLINKED);
+ log_warn(_("Inode #%"PRIu64" (0x%"PRIx64"): extended attribute leaf "
+ "block #%"PRIu64" (0x%"PRIx64") is invalid or out of "
+ "range.\n"),
+ ip->i_addr, ip->i_addr, block, block);
+ fsck_blockmap_set(ip, ip->i_eattr, _("bad (out of range) extended attribute leaf"),
+ GFS2_BLKST_UNLINKED);
return 1;
}
return check_ealeaf_block(ip, block, GFS2_METATYPE_EA, bh, private);
@@ -1087,13 +1033,10 @@ static int mark_block_invalid(struct gfs2_inode *ip, uint64_t block,
if (was_duplicate)
*was_duplicate = 1;
add_duplicate_ref(ip, block, reftype, 0, INODE_INVALID);
- log_info( _("%s block %lld (0x%llx), part of inode "
- "%lld (0x%llx), was previously referenced so "
- "the invalid reference is ignored.\n"),
- btype, (unsigned long long)block,
- (unsigned long long)block,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_info(_("%s block %"PRIu64" (0x%"PRIx64"), part of inode "
+ "%"PRIu64" (0x%"PRIx64"), was previously referenced so "
+ "the invalid reference is ignored.\n"),
+ btype, block, block, ip->i_addr, ip->i_addr);
return META_IS_GOOD;
}
fsck_blockmap_set(ip, block, btype, GFS2_BLKST_UNLINKED);
@@ -1181,11 +1124,9 @@ static int rangecheck_block(struct gfs2_inode *ip, uint64_t block,
if (!valid_block_ip(ip, block)) {
(*bad_pointers)++;
- log_info( _("Bad %s block pointer (invalid or out of range "
- "#%ld) found in inode %lld (0x%llx).\n"),
- btypes[btype], *bad_pointers,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_info(_("Bad %s block pointer (invalid or out of range "
+ "#%ld) found in inode %"PRIu64" (0x%"PRIx64").\n"),
+ btypes[btype], *bad_pointers, ip->i_addr, ip->i_addr);
if ((*bad_pointers) <= BAD_POINTER_TOLERANCE)
return META_IS_GOOD;
else
@@ -1195,19 +1136,15 @@ static int rangecheck_block(struct gfs2_inode *ip, uint64_t block,
q = block_type(bl, block);
if (q != GFS2_BLKST_FREE) {
(*bad_pointers)++;
- log_info( _("Duplicated %s block pointer (violation %ld, block"
- " %lld (0x%llx)) found in inode %lld (0x%llx).\n"),
- btypes[btype], *bad_pointers,
- (unsigned long long)block, (unsigned long long)block,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_info(_("Duplicated %s block pointer (violation %ld, block %"PRIu64
+ " (0x%"PRIx64")) found in inode %"PRIu64" (0x%"PRIx64").\n"),
+ btypes[btype], *bad_pointers, block, block, ip->i_addr, ip->i_addr);
if ((*bad_pointers) <= BAD_POINTER_TOLERANCE)
return META_IS_GOOD;
else {
- log_debug(_("Inode 0x%llx bad pointer tolerance "
- "exceeded: block 0x%llx.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)block);
+ log_debug(_("Inode 0x%"PRIx64" bad pointer tolerance "
+ "exceeded: block 0x%"PRIx64".\n"),
+ ip->i_addr, block);
return META_ERROR; /* Exits check_metatree quicker */
}
}
@@ -1277,13 +1214,14 @@ struct metawalk_fxns eattr_undo_fxns = {
static int set_ip_blockmap(struct gfs2_inode *ip)
{
uint64_t block = ip->i_bh->b_blocknr;
+ struct gfs2_inum no;
uint32_t mode;
const char *ty;
if (ip->i_sbd->gfs1)
mode = gfs_to_gfs2_mode(ip);
else
- mode = ip->i_di.di_mode & S_IFMT;
+ mode = ip->i_mode & S_IFMT;
switch (mode) {
case S_IFDIR:
@@ -1310,8 +1248,10 @@ static int set_ip_blockmap(struct gfs2_inode *ip)
default:
return -EINVAL;
}
+ no.no_addr = ip->i_addr;
+ no.no_formal_ino = ip->i_formal_ino;
if (fsck_blockmap_set(ip, block, ty, GFS2_BLKST_DINODE) ||
- (mode == S_IFDIR && !dirtree_insert(ip->i_di.di_num))) {
+ (mode == S_IFDIR && !dirtree_insert(no))) {
stack;
return -EPERM;
}
@@ -1409,8 +1349,7 @@ static int pass1_check_metatree(struct gfs2_inode *ip,
error = check_metatree(ip, pass);
if (error)
- gfs2_blockmap_set(bl, ip->i_di.di_num.no_addr,
- GFS2_BLKST_FREE);
+ gfs2_blockmap_set(bl, ip->i_addr, GFS2_BLKST_FREE);
return error;
}
@@ -1436,11 +1375,9 @@ static void reprocess_inode(struct gfs2_inode *ip, const char *desc)
int error;
alloc_fxns.private = (void *)desc;
- log_info( _("%s inode %llu (0x%llx) had blocks added; reprocessing "
- "its metadata tree at height=%d.\n"), desc,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- ip->i_di.di_height);
+ log_info(_("%s inode %"PRIu64" (0x%"PRIx64") had blocks added; reprocessing "
+ "its metadata tree at height=%d.\n"), desc,
+ ip->i_addr, ip->i_addr, ip->i_height);
error = pass1_check_metatree(ip, &alloc_fxns);
if (error)
log_err( _("Error %d reprocessing the %s metadata tree.\n"),
@@ -1466,13 +1403,9 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
rangecheck_fxns.private = &bad_pointers;
error = pass1_check_metatree(ip, &rangecheck_fxns);
if (bad_pointers > BAD_POINTER_TOLERANCE) {
- log_err( _("Error: inode %llu (0x%llx) has more than "
- "%d bad pointers.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- BAD_POINTER_TOLERANCE);
- fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
- _("badly corrupt"), GFS2_BLKST_FREE);
+ log_err(_("Error: inode %"PRIu64" (0x%"PRIx64") has more than %d bad pointers.\n"),
+ ip->i_addr, ip->i_addr, BAD_POINTER_TOLERANCE);
+ fsck_blockmap_set(ip, ip->i_addr, _("badly corrupt"), GFS2_BLKST_FREE);
return 0;
}
@@ -1484,8 +1417,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
processed its metadata with pass1_fxns, none of its
metadata will be flagged as metadata or data blocks yet.
Therefore, we don't need to invalidate anything. */
- fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,
- _("invalid mode"), GFS2_BLKST_FREE);
+ fsck_blockmap_set(ip, ip->i_addr, _("invalid mode"), GFS2_BLKST_FREE);
return 0;
} else if (error)
goto bad_dinode;
@@ -1494,7 +1426,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
goto bad_dinode;
if (lf_dip)
- lf_blks = lf_dip->i_di.di_blocks;
+ lf_blks = lf_dip->i_blocks;
pass1_fxns.private = &bc;
error = pass1_check_metatree(ip, &pass1_fxns);
@@ -1502,7 +1434,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
/* Pass1 may have added some blocks to lost+found by virtue of leafs
that were misplaced. If it did, we need to reprocess lost+found
to correctly account for its blocks. */
- if (lf_dip && lf_dip->i_di.di_blocks != lf_blks)
+ if (lf_dip && lf_dip->i_blocks != lf_blks)
reprocess_inode(lf_dip, "lost+found");
/* We there was an error, we return 0 because we want fsck to continue
@@ -1521,9 +1453,8 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
return 0;
}
log_err(_("Clearing the bad Extended Attributes in "
- "inode %lld (0x%llx).\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ "inode %"PRIu64" (0x%"PRIx64").\n"),
+ ip->i_addr, ip->i_addr);
eattr_undo_fxns.private = &bc;
check_inode_eattr(ip, &eattr_undo_fxns);
ask_remove_inode_eattr(ip, &bc);
@@ -1531,33 +1462,22 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
}
}
- if (ip->i_di.di_blocks !=
- (1 + bc.indir_count + bc.data_count + bc.ea_count)) {
- log_err( _("Inode #%llu (0x%llx): Ondisk block count (%llu"
- ") does not match what fsck found (%llu)\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_blocks,
- (unsigned long long)1 + bc.indir_count +
- bc.data_count + bc.ea_count);
- log_info( _("inode has: %lld, but fsck counts: Dinode:1 + "
- "indir:%lld + data: %lld + ea: %lld\n"),
- (unsigned long long)ip->i_di.di_blocks,
- (unsigned long long)bc.indir_count,
- (unsigned long long)bc.data_count,
- (unsigned long long)bc.ea_count);
+ if (ip->i_blocks != (1 + bc.indir_count + bc.data_count + bc.ea_count)) {
+ log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): Ondisk block count (%"PRIu64
+ ") does not match what fsck found (%"PRIu64")\n"),
+ ip->i_addr, ip->i_addr, ip->i_blocks, 1 + bc.indir_count +
+ bc.data_count + bc.ea_count);
+ log_info(_("inode has: %"PRIu64", but fsck counts: Dinode:1 + "
+ "indir:%"PRIu64" + data: %"PRIu64" + ea: %"PRIu64"\n"),
+ ip->i_blocks, bc.indir_count, bc.data_count, bc.ea_count);
if (query( _("Fix ondisk block count? (y/n) "))) {
- ip->i_di.di_blocks = 1 + bc.indir_count + bc.data_count +
- bc.ea_count;
+ ip->i_blocks = 1 + bc.indir_count + bc.data_count + bc.ea_count;
bmodified(ip->i_bh);
- log_err( _("Block count for #%llu (0x%llx) fixed\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Block count for #%"PRIu64" (0x%"PRIx64") fixed\n"),
+ ip->i_addr, ip->i_addr);
} else
- log_err( _("Bad block count for #%llu (0x%llx"
- ") not fixed\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Bad block count for #%"PRIu64" (0x%"PRIx64") not fixed\n"),
+ ip->i_addr, ip->i_addr);
}
return 0;
@@ -1568,27 +1488,22 @@ bad_dinode:
static void check_i_goal(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
{
- if (sdp->gfs1 || ip->i_di.di_flags & GFS2_DIF_SYSTEM)
+ if (sdp->gfs1 || ip->i_flags & GFS2_DIF_SYSTEM)
return;
- if (ip->i_di.di_goal_meta <= LGFS2_SB_ADDR(sdp) ||
- ip->i_di.di_goal_meta > sdp->fssize) {
- log_err(_("Inode #%llu (0x%llx): Bad allocation goal block "
- "found: %llu (0x%llx)\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_goal_meta,
- (unsigned long long)ip->i_di.di_goal_meta);
- if (query( _("Fix goal block in inode #%llu (0x%llx)? (y/n) "),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr)) {
- ip->i_di.di_goal_meta = ip->i_di.di_num.no_addr;
+ if (ip->i_goal_meta <= LGFS2_SB_ADDR(sdp) ||
+ ip->i_goal_meta > sdp->fssize) {
+ log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): Bad allocation goal block "
+ "found: %"PRIu64" (0x%"PRIx64")\n"),
+ ip->i_addr, ip->i_addr, ip->i_goal_meta, ip->i_goal_meta);
+ if (query(_("Fix goal block in inode #%"PRIu64" (0x%"PRIx64")? (y/n) "),
+ ip->i_addr, ip->i_addr)) {
+ ip->i_goal_meta = ip->i_addr;
bmodified(ip->i_bh);
} else
- log_err(_("Allocation goal block in inode #%lld "
- "(0x%llx) not fixed\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Allocation goal block in inode #%"PRIu64
+ " (0x%"PRIx64") not fixed\n"),
+ ip->i_addr, ip->i_addr);
}
}
@@ -1605,33 +1520,25 @@ static int handle_di(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
ip = fsck_inode_get(sdp, rgd, bh);
- if (ip->i_di.di_num.no_addr != block) {
- log_err( _("Inode #%llu (0x%llx): Bad inode address found: %llu "
- "(0x%llx)\n"), (unsigned long long)block,
- (unsigned long long)block,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
- if (query( _("Fix address in inode at block #%llu"
- " (0x%llx)? (y/n) "),
- (unsigned long long)block, (unsigned long long)block)) {
- ip->i_di.di_num.no_addr = ip->i_di.di_num.no_formal_ino = block;
+ if (ip->i_addr != block) {
+ log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): Bad inode address found: %"PRIu64
+ " (0x%"PRIx64")\n"),
+ block, block, ip->i_addr, ip->i_addr);
+ if (query(_("Fix address in inode at block #%"PRIu64" (0x%"PRIx64")? (y/n) "),
+ block, block)) {
+ ip->i_addr = ip->i_formal_ino = block;
bmodified(ip->i_bh);
} else
- log_err( _("Address in inode at block #%llu"
- " (0x%llx) not fixed\n"),
- (unsigned long long)block,
- (unsigned long long)block);
- }
- if (sdp->gfs1 && ip->i_di.di_num.no_formal_ino != block) {
- log_err( _("Inode #%llu (0x%llx): GFS1 formal inode number "
- "mismatch: was %llu (0x%llx)\n"),
- (unsigned long long)block, (unsigned long long)block,
- (unsigned long long)ip->i_di.di_num.no_formal_ino,
- (unsigned long long)ip->i_di.di_num.no_formal_ino);
- if (query( _("Fix formal inode number in inode #%llu"
- " (0x%llx)? (y/n) "), (unsigned long long)block,
- (unsigned long long)block)) {
- ip->i_di.di_num.no_formal_ino = block;
+ log_err(_("Address in inode at block #%"PRIu64" (0x%"PRIx64" not fixed\n"),
+ block, block);
+ }
+ if (sdp->gfs1 && ip->i_formal_ino != block) {
+ log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): GFS1 formal inode number "
+ "mismatch: was %"PRIu64" (0x%"PRIx64")\n"),
+ block, block, ip->i_formal_ino, ip->i_formal_ino);
+ if (query(_("Fix formal inode number in inode #%"PRIu64" (0x%"PRIx64")? (y/n) "),
+ block, block)) {
+ ip->i_formal_ino = block;
bmodified(ip->i_bh);
} else
log_err( _("Inode number in inode at block #%lld "
@@ -1663,7 +1570,7 @@ static int check_system_inode(struct gfs2_sbd *sdp,
if (*sysinode) {
/* Read in the system inode, look at its dentries, and start
* reading through them */
- iblock = (*sysinode)->i_di.di_num.no_addr;
+ iblock = (*sysinode)->i_addr;
log_info( _("System inode for '%s' is located at block %llu"
" (0x%llx)\n"), filename,
(unsigned long long)iblock,
@@ -1688,16 +1595,20 @@ static int check_system_inode(struct gfs2_sbd *sdp,
if (ds.q == GFS2_BLKST_FREE) {
log_info( _("The inode exists but the block is not "
"marked 'in use'; fixing it.\n"));
- fsck_blockmap_set(*sysinode,
- (*sysinode)->i_di.di_num.no_addr,
+ fsck_blockmap_set(*sysinode, (*sysinode)->i_addr,
filename, GFS2_BLKST_DINODE);
ds.q = GFS2_BLKST_DINODE;
- if (isdir)
- dirtree_insert((*sysinode)->i_di.di_num);
+ if (isdir) {
+ struct gfs2_inum no = {
+ .no_addr = (*sysinode)->i_addr,
+ .no_formal_ino = (*sysinode)->i_formal_ino
+ };
+ dirtree_insert(no);
+ }
}
/* Make sure it's marked as a system file/directory */
if (needs_sysbit &&
- !((*sysinode)->i_di.di_flags & GFS2_DIF_SYSTEM)) {
+ !((*sysinode)->i_flags & GFS2_DIF_SYSTEM)) {
log_err( _("System inode %s is missing the 'system' "
"flag. It should be rebuilt.\n"), filename);
if (sysdir && query(_("Delete the corrupt %s system "
@@ -1737,23 +1648,27 @@ static int check_system_inode(struct gfs2_sbd *sdp,
}
if (*sysinode == sdp->md.jiinode)
ji_update(sdp);
- fsck_blockmap_set(*sysinode,
- (*sysinode)->i_di.di_num.no_addr,
+ fsck_blockmap_set(*sysinode, (*sysinode)->i_addr,
filename, GFS2_BLKST_DINODE);
ds.q = GFS2_BLKST_DINODE;
- if (isdir)
- dirtree_insert((*sysinode)->i_di.di_num);
+ if (isdir) {
+ struct gfs2_inum no = {
+ .no_addr = (*sysinode)->i_addr,
+ .no_formal_ino = (*sysinode)->i_formal_ino
+ };
+ dirtree_insert(no);
+ }
} else {
log_err( _("Cannot continue without valid %s inode\n"),
filename);
return -1;
}
}
- if (is_dir(&(*sysinode)->i_di, sdp->gfs1)) {
+ if (is_dir(*sysinode, sdp->gfs1)) {
struct block_count bc = {0};
sysdir_fxns.private = &bc;
- if ((*sysinode)->i_di.di_flags & GFS2_DIF_EXHASH)
+ if ((*sysinode)->i_flags & GFS2_DIF_EXHASH)
pass1_check_metatree(*sysinode, &sysdir_fxns);
else {
err = check_linear_dir(*sysinode, (*sysinode)->i_bh,
@@ -1799,8 +1714,7 @@ static int check_system_inodes(struct gfs2_sbd *sdp)
All other system dinodes in master will be taken care of by function
resuscitate_metalist. But master won't since it has no parent.*/
if (!sdp->gfs1) {
- fsck_blockmap_set(sdp->master_dir,
- sdp->master_dir->i_di.di_num.no_addr,
+ fsck_blockmap_set(sdp->master_dir, sdp->master_dir->i_addr,
"master", GFS2_BLKST_DINODE);
if (check_system_inode(sdp, &sdp->master_dir, "master",
build_master, 1, NULL, 1)) {
@@ -1810,7 +1724,7 @@ static int check_system_inodes(struct gfs2_sbd *sdp)
}
/* Mark the root dinode as a "dinode" in the block map as we did
for master, since it has no parent. */
- fsck_blockmap_set(sdp->md.rooti, sdp->md.rooti->i_di.di_num.no_addr,
+ fsck_blockmap_set(sdp->md.rooti, sdp->md.rooti->i_addr,
"root", GFS2_BLKST_DINODE);
if (check_system_inode(sdp, &sdp->md.rooti, "root", build_root, 1,
NULL, 0)) {
@@ -1855,17 +1769,22 @@ static int check_system_inodes(struct gfs2_sbd *sdp)
journal_count = sdp->md.journals;
/* gfs1's journals aren't dinode, they're just a bunch of blocks. */
if (sdp->gfs1) {
+ struct gfs2_inum no;
/* gfs1 has four dinodes that are set in the superblock and
therefore not linked to anything else. We need to adjust
the link counts so pass4 doesn't get confused. */
- incr_link_count(sdp->md.statfs->i_di.di_num, NULL,
- _("gfs1 statfs inode"));
- incr_link_count(sdp->md.jiinode->i_di.di_num, NULL,
- _("gfs1 jindex inode"));
- incr_link_count(sdp->md.riinode->i_di.di_num, NULL,
- _("gfs1 rindex inode"));
- incr_link_count(sdp->md.qinode->i_di.di_num, NULL,
- _("gfs1 quota inode"));
+ no.no_addr = sdp->md.statfs->i_addr;
+ no.no_formal_ino = sdp->md.statfs->i_formal_ino;
+ incr_link_count(no, NULL, _("gfs1 statfs inode"));
+ no.no_addr = sdp->md.jiinode->i_addr;
+ no.no_formal_ino = sdp->md.jiinode->i_formal_ino;
+ incr_link_count(no, NULL, _("gfs1 jindex inode"));
+ no.no_addr = sdp->md.riinode->i_addr;
+ no.no_formal_ino = sdp->md.riinode->i_formal_ino;
+ incr_link_count(no, NULL, _("gfs1 rindex inode"));
+ no.no_addr = sdp->md.qinode->i_addr;
+ no.no_formal_ino = sdp->md.qinode->i_formal_ino;
+ incr_link_count(no, NULL, _("gfs1 quota inode"));
return 0;
}
for (sdp->md.journals = 0; sdp->md.journals < journal_count;
@@ -1960,7 +1879,7 @@ static int pass1_process_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd, uin
(unsigned long long)block,
block_type_string(q));
ip = fsck_inode_get(sdp, rgd, bh);
- if (is_inode && ip->i_di.di_num.no_addr == block)
+ if (is_inode && ip->i_addr == block)
add_duplicate_ref(ip, block, REF_IS_INODE, 0,
INODE_VALID);
else
diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c
index a6f06ade..8d702959 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -328,11 +328,11 @@ static void resolve_dup_references(struct gfs2_sbd *sdp, struct duptree *dt,
because it IS ours, and we need to remove all the
eattr leaf blocks: they do belong to us (except for
the duplicate referenced one, which is handled). */
- if (ip->i_di.di_eattr == dt->block) {
- ip->i_di.di_eattr = 0;
- if (ip->i_di.di_blocks > 0)
- ip->i_di.di_blocks--;
- ip->i_di.di_flags &= ~GFS2_DIF_EA_INDIRECT;
+ if (ip->i_eattr == dt->block) {
+ ip->i_eattr = 0;
+ if (ip->i_blocks > 0)
+ ip->i_blocks--;
+ ip->i_flags &= ~GFS2_DIF_EA_INDIRECT;
bmodified(ip->i_bh);
dup_listent_delete(dt, id);
(dh->ref_inode_count)--;
@@ -350,17 +350,17 @@ static void resolve_dup_references(struct gfs2_sbd *sdp, struct duptree *dt,
and dirtree entries exist. That way, the
bitmap_set will do proper accounting for
the rgrp dinode count. */
- fsck_bitmap_set(ip, ip->i_di.di_num.no_addr,
+ fsck_bitmap_set(ip, ip->i_addr,
_("duplicate referencing bad"),
GFS2_BLKST_FREE);
/* Remove the inode from the inode tree */
- ii = inodetree_find(ip->i_di.di_num.no_addr);
+ ii = inodetree_find(ip->i_addr);
if (ii)
inodetree_delete(ii);
- di = dirtree_find(ip->i_di.di_num.no_addr);
+ di = dirtree_find(ip->i_addr);
if (di)
dirtree_delete(di);
- link1_set(&nlink1map, ip->i_di.di_num.no_addr,
+ link1_set(&nlink1map, ip->i_addr,
0);
/* We delete the dup_handler inode count and
duplicate id BEFORE clearing the metadata,
@@ -422,20 +422,15 @@ static int clone_data(struct gfs2_inode *ip, uint64_t metablock,
return 0;
if (clonet->first) {
- log_debug(_("Inode %lld (0x%llx)'s first reference to "
- "block %lld (0x%llx) is targeted for cloning.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)block,
- (unsigned long long)block);
+ log_debug(_("Inode %"PRIu64" (0x%"PRIx64")'s first reference to "
+ "block %"PRIu64" (0x%"PRIx64") is targeted for cloning.\n"),
+ ip->i_addr, ip->i_addr, block, block);
clonet->first = 0;
return 0;
}
- log_err(_("Error: Inode %lld (0x%llx)'s reference to block %lld "
- "(0x%llx) should be replaced with a clone.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)block, (unsigned long long)block);
+ log_err(_("Error: Inode %"PRIu64" (0x%"PRIx64")'s reference to block %"PRIu64
+ " (0x%"PRIx64") should be replaced with a clone.\n"),
+ ip->i_addr, ip->i_addr, block, block);
if (query( _("Okay to clone the duplicated reference? (y/n) "))) {
error = lgfs2_meta_alloc(ip, &cloneblock);
if (!error) {
@@ -496,16 +491,13 @@ static void clone_dup_ref_in_inode(struct gfs2_inode *ip, struct duptree *dt)
.check_data = clone_data,
};
- log_err(_("There are multiple references to block %lld (0x%llx) in "
- "inode %lld (0x%llx)\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)dt->block, (unsigned long long)dt->block);
+ log_err(_("There are multiple references to block %"PRIu64" (0x%"PRIx64") in "
+ "inode %"PRIu64" (0x%"PRIx64")\n"),
+ ip->i_addr, ip->i_addr, dt->block, dt->block);
error = check_metatree(ip, &pass1b_fxns_clone);
if (error) {
- log_err(_("Error cloning duplicate reference(s) to block %lld "
- "(0x%llx).\n"), (unsigned long long)dt->block,
- (unsigned long long)dt->block);
+ log_err(_("Error cloning duplicate reference(s) to block %"PRIu64
+ " (0x%"PRIx64").\n"), dt->block, dt->block);
}
}
@@ -518,7 +510,7 @@ static int set_ip_bitmap(struct gfs2_inode *ip)
if (ip->i_sbd->gfs1)
mode = gfs_to_gfs2_mode(ip);
else
- mode = ip->i_di.di_mode & S_IFMT;
+ mode = ip->i_mode & S_IFMT;
switch (mode) {
case S_IFDIR:
@@ -590,7 +582,7 @@ static void resolve_last_reference(struct gfs2_sbd *sdp, struct duptree *dt,
fsck_bitmap_set(ip, dt->block, _("reference-repaired data"),
GFS2_BLKST_USED);
} else if (id->reftypecount[REF_AS_META]) {
- if (is_dir(&ip->i_di, sdp->gfs1))
+ if (is_dir(ip, sdp->gfs1))
fsck_bitmap_set(ip, dt->block,
_("reference-repaired leaf"),
sdp->gfs1 ? GFS2_BLKST_DINODE :
@@ -621,9 +613,9 @@ static void resolve_last_reference(struct gfs2_sbd *sdp, struct duptree *dt,
"(y/n) "),
(unsigned long long)id->block_no,
(unsigned long long)id->block_no)) {
- ip->i_di.di_eattr = 0;
- ip->i_di.di_flags &= ~GFS2_DIF_EA_INDIRECT;
- ip->i_di.di_blocks--;
+ ip->i_eattr = 0;
+ ip->i_flags &= ~GFS2_DIF_EA_INDIRECT;
+ ip->i_blocks--;
bmodified(ip->i_bh);
fsck_bitmap_set(ip, dt->block,
_("reference-repaired EA"),
@@ -882,8 +874,8 @@ static int find_block_ref(struct gfs2_sbd *sdp, uint64_t inode)
ip = fsck_load_inode(sdp, inode); /* bread, inode_get */
/* double-check the meta header just to be sure it's metadata */
- if (ip->i_di.di_header.mh_magic != GFS2_MAGIC ||
- ip->i_di.di_header.mh_type != GFS2_METATYPE_DI) {
+ if (ip->i_magic != GFS2_MAGIC ||
+ ip->i_type != GFS2_METATYPE_DI) {
if (!sdp->gfs1)
log_debug( _("Block %lld (0x%llx) is not a dinode.\n"),
(unsigned long long)inode,
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index e595051d..d5fe61b3 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -92,7 +92,7 @@ static int set_dotdot_dir(struct gfs2_sbd *sdp, uint64_t childblock,
}
/* Special case for root inode because we set it earlier */
if (di->dotdot_parent.no_addr &&
- sdp->md.rooti->i_di.di_num.no_addr != di->dinode.no_addr) {
+ sdp->md.rooti->i_addr != di->dinode.no_addr) {
/* This should never happen */
log_crit( _("Dotdot parent already set for block %llu (0x%llx)"
"-> %llu (0x%llx)\n"),
@@ -199,17 +199,15 @@ static int bad_formal_ino(struct gfs2_inode *ip, struct gfs2_dirent *dent,
struct gfs2_inode *dent_ip;
dent_ip = fsck_load_inode(ip->i_sbd, entry.no_addr);
- inum = dent_ip->i_di.di_num;
+ inum.no_addr = dent_ip->i_addr;
+ inum.no_formal_ino = dent_ip->i_formal_ino;
fsck_inode_put(&dent_ip);
}
}
- log_err( _("Directory entry '%s' pointing to block %llu (0x%llx) in "
- "directory %llu (0x%llx) has the wrong 'formal' inode "
- "number.\n"), tmp_name, (unsigned long long)entry.no_addr,
- (unsigned long long)entry.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
- log_err( _("The directory entry has %llu (0x%llx) but the inode has "
+ log_err(_("Directory entry '%s' pointing to block %"PRIu64" (0x%"PRIx64") in "
+ "directory %"PRIu64" (0x%"PRIx64") has the wrong 'formal' inode number.\n"),
+ tmp_name, entry.no_addr, entry.no_addr, ip->i_addr, ip->i_addr);
+ log_err(_("The directory entry has %llu (0x%llx) but the inode has "
"%llu (0x%llx)\n"), (unsigned long long)entry.no_formal_ino,
(unsigned long long)entry.no_formal_ino,
(unsigned long long)inum.no_formal_ino,
@@ -225,17 +223,20 @@ static int bad_formal_ino(struct gfs2_inode *ip, struct gfs2_dirent *dent,
has a '..' pointing back, just fix up the no_formal_ino. */
child_ip = lgfs2_inode_read(sdp, entry.no_addr);
error = dir_search(child_ip, "..", 2, NULL, &childs_dotdot);
- if (!error && childs_dotdot.no_addr == ip->i_di.di_num.no_addr) {
+ if (!error && childs_dotdot.no_addr == ip->i_addr) {
log_err( _("The entry points to another directory with intact "
"linkage.\n"));
if (query( _("Fix the bad directory entry? (y/n) "))) {
+ struct gfs2_inum no;
log_err( _("Fixing the corrupt directory entry.\n"));
entry.no_formal_ino = inum.no_formal_ino;
de->de_inum.no_formal_ino = entry.no_formal_ino;
gfs2_dirent_out(de, (char *)dent);
bmodified(bh);
incr_link_count(entry, ip, _("fixed reference"));
- set_parent_dir(sdp, entry, ip->i_di.di_num);
+ no.no_addr = ip->i_addr;
+ no.no_formal_ino = ip->i_formal_ino;
+ set_parent_dir(sdp, entry, no);
} else {
log_err( _("Directory entry not fixed.\n"));
}
@@ -252,14 +253,14 @@ static int bad_formal_ino(struct gfs2_inode *ip, struct gfs2_dirent *dent,
static int hash_table_index(uint32_t hash, struct gfs2_inode *ip)
{
- return hash >> (32 - ip->i_di.di_depth);
+ return hash >> (32 - ip->i_depth);
}
static int hash_table_max(int lindex, struct gfs2_inode *ip,
struct gfs2_buffer_head *bh)
{
struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
- return (1 << (ip->i_di.di_depth - be16_to_cpu(leaf->lf_depth))) +
+ return (1 << (ip->i_depth - be16_to_cpu(leaf->lf_depth))) +
lindex - 1;
}
@@ -268,7 +269,7 @@ static int check_leaf_depth(struct gfs2_inode *ip, uint64_t leaf_no,
{
struct gfs2_leaf *leaf = (struct gfs2_leaf *)lbh->b_data;
int cur_depth = be16_to_cpu(leaf->lf_depth);
- int exp_count = 1 << (ip->i_di.di_depth - cur_depth);
+ int exp_count = 1 << (ip->i_depth - cur_depth);
int divisor;
int factor, correct_depth;
@@ -281,20 +282,17 @@ static int check_leaf_depth(struct gfs2_inode *ip, uint64_t leaf_no,
factor++;
divisor >>= 1;
}
- if (ip->i_di.di_depth < factor) /* can't be fixed--leaf must be on the
+ if (ip->i_depth < factor) /* can't be fixed--leaf must be on the
wrong dinode. */
return -1;
- correct_depth = ip->i_di.di_depth - factor;
+ correct_depth = ip->i_depth - factor;
if (cur_depth == correct_depth)
return 0;
- log_err(_("Leaf block %llu (0x%llx) in dinode %llu (0x%llx) has the "
- "wrong depth: is %d (length %d), should be %d (length "
- "%d).\n"),
- (unsigned long long)leaf_no, (unsigned long long)leaf_no,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- cur_depth, ref_count, correct_depth, exp_count);
+ log_err(_("Leaf block %"PRIu64" (0x%"PRIx64") in dinode %"PRIu64" (0x%"PRIx64") has the "
+ "wrong depth: is %d (length %d), should be %d (length %d).\n"),
+ leaf_no, leaf_no, ip->i_addr, ip->i_addr,
+ cur_depth, ref_count, correct_depth, exp_count);
if (!query( _("Fix the leaf block? (y/n)"))) {
log_err( _("The leaf block was not fixed.\n"));
return 0;
@@ -351,7 +349,7 @@ static int wrong_leaf(struct gfs2_inode *ip, struct gfs2_inum *entry,
(unsigned long long)planned_leaf);
/* Can't trust lf_depth; we have to count */
dest_ref = 0;
- for (li = 0; li < (1 << ip->i_di.di_depth); li++) {
+ for (li = 0; li < (1 << ip->i_depth); li++) {
if (be64_to_cpu(tbl[li]) == planned_leaf)
dest_ref++;
else if (dest_ref)
@@ -372,26 +370,24 @@ static int wrong_leaf(struct gfs2_inode *ip, struct gfs2_inum *entry,
return 1; /* nuke the dent upon return */
}
- di_depth = ip->i_di.di_depth;
+ di_depth = ip->i_depth;
if (dir_add(ip, tmp_name, de->de_name_len, &de->de_inum,
de->de_type) == 0) {
log_err(_("The misplaced directory entry was moved to a "
"valid leaf block.\n"));
- if (ip->i_di.di_depth > di_depth) {
+ if (ip->i_depth > di_depth) {
log_err(_("Directory hash table was doubled.\n"));
- hash_index <<= (ip->i_di.di_depth - di_depth);
- (*lindex) <<= (ip->i_di.di_depth - di_depth);
+ hash_index <<= (ip->i_depth - di_depth);
+ (*lindex) <<= (ip->i_depth - di_depth);
}
if (lgfs2_get_leaf_ptr(ip, hash_index, &real_leaf)) {
log_err(_("Could not read leaf %d in dinode %"PRIu64": %s\n"), hash_index,
- (uint64_t)ip->i_di.di_num.no_addr, strerror(errno));
+ ip->i_addr, strerror(errno));
}
if (real_leaf != planned_leaf) {
log_err(_("The planned leaf was split. The new leaf "
- "is: %llu (0x%llx). di_blocks=%llu\n"),
- (unsigned long long)real_leaf,
- (unsigned long long)real_leaf,
- (unsigned long long)ip->i_di.di_blocks);
+ "is: %"PRIu64" (0x%"PRIx64"). di_blocks=%"PRIu64"\n"),
+ real_leaf, real_leaf, ip->i_blocks);
fsck_bitmap_set(ip, real_leaf, _("split leaf"),
sdp->gfs1 ? GFS2_BLKST_DINODE :
GFS2_BLKST_USED);
@@ -411,8 +407,11 @@ static int wrong_leaf(struct gfs2_inode *ip, struct gfs2_inum *entry,
to nuke the dent from this leaf when we return, but we
still need to do the "good dent" accounting. */
if (de->de_type == (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR)) {
- error = set_parent_dir(sdp, de->de_inum,
- ip->i_di.di_num);
+ struct gfs2_inum no = {
+ .no_addr = ip->i_addr,
+ .no_formal_ino = ip->i_formal_ino
+ };
+ error = set_parent_dir(sdp, de->de_inum, no);
if (error > 0)
/* This is a bit of a kludge, but returning 0
in this case causes the caller to go through
@@ -467,12 +466,10 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
*isdir = 0;
if (!valid_block_ip(ip, entry->no_addr)) {
- log_err( _("Block # referenced by directory entry %s in inode "
- "%lld (0x%llx) is invalid\n"),
- tmp_name, (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
- if (query( _("Clear directory entry to out of range block? "
- "(y/n) "))) {
+ log_err(_("Block # referenced by directory entry %s in inode %"PRIu64
+ " (0x%"PRIx64") is invalid\n"),
+ tmp_name, ip->i_addr, ip->i_addr);
+ if (query( _("Clear directory entry to out of range block? (y/n) "))) {
return 1;
} else {
log_err( _("Directory entry to out of range block remains\n"));
@@ -540,19 +537,14 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
* metadata tree deleted.
*/
if (*q != GFS2_BLKST_DINODE) {
- log_err( _("Directory entry '%s' referencing inode %llu "
- "(0x%llx) in dir inode %llu (0x%llx) block type "
- "%d: %s.\n"), tmp_name,
- (unsigned long long)entry->no_addr,
- (unsigned long long)entry->no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
+ log_err(_("Directory entry '%s' referencing inode %"PRIu64" (0x%"PRIx64") "
+ "in dir inode %"PRIu64" (0x%"PRIx64") block type %d: %s.\n"),
+ tmp_name, entry->no_addr, entry->no_addr, ip->i_addr, ip->i_addr,
*q, *q == GFS2_BLKST_FREE ?
_("was previously marked invalid") :
_("was deleted or is not an inode"));
- if (!query( _("Clear directory entry to non-inode block? "
- "(y/n) "))) {
+ if (!query(_("Clear directory entry to non-inode block? (y/n) "))) {
log_err( _("Directory entry to non-inode block remains\n"));
return 0;
}
@@ -579,13 +571,9 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
error = check_file_type(entry->no_addr, de->de_type, *q, sdp->gfs1,
isdir);
if (error < 0) {
- log_err( _("Error: directory entry type is "
- "incompatible with block type at block %lld "
- "(0x%llx) in directory inode %llu (0x%llx).\n"),
- (unsigned long long)entry->no_addr,
- (unsigned long long)entry->no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Error: directory entry type is incompatible with block type at block %"PRIu64
+ " (0x%"PRIx64") in directory inode %"PRIu64" (0x%"PRIx64").\n"),
+ entry->no_addr, entry->no_addr, ip->i_addr, ip->i_addr);
log_err( _("Directory entry type is %d, block type is %d.\n"),
de->de_type, *q);
stack;
@@ -602,7 +590,7 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
log_err( _("Stale directory entry remains\n"));
return 0;
}
- if (ip->i_di.di_num.no_addr == entry->no_addr)
+ if (ip->i_addr == entry->no_addr)
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry->no_addr);
@@ -628,19 +616,13 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
}
}
if (inum.no_formal_ino != entry->no_formal_ino) {
- log_err( _("Directory entry '%s' pointing to block %llu "
- "(0x%llx) in directory %llu (0x%llx) has the "
- "wrong 'formal' inode number.\n"), tmp_name,
- (unsigned long long)entry->no_addr,
- (unsigned long long)entry->no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
- log_err( _("The directory entry has %llu (0x%llx) but the "
- "inode has %llu (0x%llx)\n"),
- (unsigned long long)entry->no_formal_ino,
- (unsigned long long)entry->no_formal_ino,
- (unsigned long long)inum.no_formal_ino,
- (unsigned long long)inum.no_formal_ino);
+ log_err(_("Directory entry '%s' pointing to block %"PRIu64" (0x%"PRIx64") "
+ "in directory %"PRIu64" (0x%"PRIx64") has the wrong 'formal' inode number.\n"),
+ tmp_name, entry->no_addr, entry->no_addr, ip->i_addr, ip->i_addr);
+ log_err(_("The directory entry has %"PRIu64" (0x%"PRIx64") but the "
+ "inode has %"PRIu64" (0x%"PRIx64")\n"),
+ entry->no_formal_ino, entry->no_formal_ino,
+ inum.no_formal_ino, inum.no_formal_ino);
return 1;
}
/* Check for a special case where a (bad) GFS1 dirent points to what
@@ -652,13 +634,10 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
tbh = bread(sdp, entry->no_addr);
if (gfs2_check_meta(tbh->b_data, GFS2_METATYPE_DI)) { /* not dinode */
- log_err( _("Directory entry '%s' pointing to block "
- "%llu (0x%llx) in directory %llu (0x%llx) "
+ log_err(_("Directory entry '%s' pointing to block %"PRIu64
+ " (0x%"PRIx64") in directory %"PRIu64" (0x%"PRIx64") "
"is not really a GFS1 dinode.\n"), tmp_name,
- (unsigned long long)entry->no_addr,
- (unsigned long long)entry->no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ entry->no_addr, entry->no_addr, ip->i_addr, ip->i_addr);
brelse(tbh);
return 1;
}
@@ -691,12 +670,9 @@ static int dirref_find(struct gfs2_inode *ip, struct gfs2_dirent *dent,
"link.\n");
goto out;
}
- log_err(_("The original reference to inode %lld (0x%llx) from "
- "directory %lld (0x%llx) has the wrong 'formal' inode "
- "number.\n"), (unsigned long long)entry->no_addr,
- (unsigned long long)entry->no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("The original reference to inode %"PRIu64" (0x%"PRIx64") from "
+ "directory %"PRIu64" (0x%"PRIx64") has the wrong 'formal' inode "
+ "number.\n"), entry->no_addr, entry->no_addr, ip->i_addr, ip->i_addr);
memset(fn, 0, sizeof(fn));
if (de->de_name_len < MAX_FILENAME)
strncpy(fn, filename, de->de_name_len);
@@ -712,8 +688,8 @@ static int dirref_find(struct gfs2_inode *ip, struct gfs2_dirent *dent,
log_err(_("The corrupt directory entry was not fixed.\n"));
goto out;
}
- decr_link_count(entry->no_addr, ip->i_di.di_num.no_addr,
- ip->i_sbd->gfs1, _("bad original reference"));
+ decr_link_count(entry->no_addr, ip->i_addr, ip->i_sbd->gfs1,
+ _("bad original reference"));
dirent2_del(ip, bh, prev, dent);
log_err(_("The corrupt directory entry '%s' was deleted.\n"), fn);
out:
@@ -784,7 +760,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
struct gfs2_sbd *sdp = ip->i_sbd;
int q = 0;
char tmp_name[MAX_FILENAME];
- struct gfs2_inum entry;
+ struct gfs2_inum entry, no;
struct dir_status *ds = (struct dir_status *) priv;
int error;
struct gfs2_inode *entry_ip = NULL;
@@ -813,22 +789,19 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
goto nuke_dentry;
if (!strcmp(".", tmp_name)) {
- log_debug( _("Found . dentry in directory %lld (0x%llx)\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_debug(_("Found . dentry in directory %"PRIu64" (0x%"PRIx64")\n"),
+ ip->i_addr, ip->i_addr);
if (ds->dotdir) {
- log_err( _("Already found '.' entry in directory %llu"
- " (0x%llx)\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Already found '.' entry in directory %"PRIu64" (0x%"PRIx64")\n"),
+ ip->i_addr, ip->i_addr);
if (!query( _("Clear duplicate '.' entry? (y/n) "))) {
log_err( _("Duplicate '.' entry remains\n"));
/* FIXME: Should we continue on here
* and check the rest of the '.' entry? */
goto dentry_is_valid;
}
- if (ip->i_di.di_num.no_addr == entry.no_addr)
+ if (ip->i_addr == entry.no_addr)
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.no_addr);
@@ -842,24 +815,19 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
* location */
/* check that '.' refers to this inode */
- if (entry.no_addr != ip->i_di.di_num.no_addr) {
- log_err( _("'.' entry's value incorrect in directory %llu"
- " (0x%llx). Points to %llu"
- " (0x%llx) when it should point to %llu"
- " (0x%llx).\n"),
- (unsigned long long)entry.no_addr,
- (unsigned long long)entry.no_addr,
- (unsigned long long)entry.no_addr,
- (unsigned long long)entry.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ if (entry.no_addr != ip->i_addr) {
+ log_err(_("'.' entry's value incorrect in directory %"PRIu64" (0x%"PRIx64")."
+ " Points to %"PRIu64" (0x%"PRIx64") when it should point to %"PRIu64
+ " (0x%"PRIx64").\n"),
+ entry.no_addr, entry.no_addr, entry.no_addr, entry.no_addr,
+ ip->i_addr, ip->i_addr);
if (!query( _("Remove '.' reference? (y/n) "))) {
log_err( _("Invalid '.' reference remains\n"));
/* Not setting ds->dotdir here since
* this '.' entry is invalid */
goto dentry_is_valid;
}
- if (ip->i_di.di_num.no_addr == entry.no_addr)
+ if (ip->i_addr == entry.no_addr)
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.no_addr);
@@ -873,14 +841,11 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
goto dentry_is_valid;
}
if (!strcmp("..", tmp_name)) {
- log_debug( _("Found '..' dentry in directory %lld (0x%llx)\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_debug(_("Found '..' dentry in directory %"PRIu64" (0x%"PRIx64")\n"),
+ ip->i_addr, ip->i_addr);
if (ds->dotdotdir) {
- log_err( _("Already had a '..' entry in directory %llu"
- "(0x%llx)\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Already had a '..' entry in directory %"PRIu64" (0x%"PRIx64")\n"),
+ ip->i_addr, ip->i_addr);
if (!query( _("Clear duplicate '..' entry? (y/n) "))) {
log_err( _("Duplicate '..' entry remains\n"));
/* FIXME: Should we continue on here
@@ -889,7 +854,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
goto dentry_is_valid;
}
- if (ip->i_di.di_num.no_addr == entry.no_addr)
+ if (ip->i_addr == entry.no_addr)
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.no_addr);
@@ -900,15 +865,14 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
goto nuke_dentry;
}
if (!isdir) {
- log_err( _("Found '..' entry in directory %llu (0x%llx) "
+ log_err(_("Found '..' entry in directory %"PRIu64" (0x%"PRIx64") "
"pointing to something that's not a directory"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ ip->i_addr, ip->i_addr);
if (!query( _("Clear bad '..' directory entry? (y/n) "))) {
log_err( _("Bad '..' directory entry remains\n"));
goto dentry_is_valid;
}
- if (ip->i_di.di_num.no_addr == entry.no_addr)
+ if (ip->i_addr == entry.no_addr)
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.no_addr);
@@ -923,7 +887,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
/* Add the address this entry is pointing to
* to this inode's dotdot_parent in
* dir_info */
- if (set_dotdot_dir(sdp, ip->i_di.di_num.no_addr, entry)) {
+ if (set_dotdot_dir(sdp, ip->i_addr, entry)) {
stack;
return -1;
}
@@ -933,7 +897,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
}
/* If this is an exhash directory, make sure the dentries in the leaf
block have a hash table index that fits */
- if (ip->i_di.di_flags & GFS2_DIF_EXHASH) {
+ if (ip->i_flags & GFS2_DIF_EXHASH) {
hash_index = hash_table_index(de->de_hash, ip);
lindex_max = hash_table_max(*lindex, ip, bh);
if (hash_index < *lindex || hash_index > lindex_max) {
@@ -957,7 +921,9 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
}
/*log_debug( _("Found plain directory dentry\n"));*/
- error = set_parent_dir(sdp, entry, ip->i_di.di_num);
+ no.no_addr = ip->i_addr;
+ no.no_formal_ino = ip->i_formal_ino;
+ error = set_parent_dir(sdp, entry, no);
if (error > 0) {
log_err( _("%s: Hard link to block %llu (0x%llx"
") detected.\n"), tmp_name,
@@ -1026,10 +992,8 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
/* Make sure the number of copies is properly a factor of 2 */
if ((1 << factor) != num_copies) {
log_err(_("Program error: num_copies not a factor of 2.\n"));
- log_err(_("num_copies=%d, dinode = %lld (0x%llx)\n"),
- num_copies,
- (unsigned long long)dip->i_di.di_num.no_addr,
- (unsigned long long)dip->i_di.di_num.no_addr);
+ log_err(_("num_copies=%d, dinode = %"PRIu64" (0x%"PRIx64")\n"),
+ num_copies, dip->i_addr, dip->i_addr);
log_err(_("lindex = %d (0x%x)\n"), start_lindex, start_lindex);
stack;
free(padbuf);
@@ -1050,7 +1014,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
"pointer at index %d (0x%x).\n"), (unsigned long long)*bn,
(unsigned long long)*bn, num_copies, num_copies,
before_or_after, start_lindex, start_lindex);
- dip->i_di.di_blocks++;
+ dip->i_blocks++;
bmodified(dip->i_bh);
nbh = bget(dip->i_sbd, *bn);
memset(nbh->b_data, 0, dip->i_sbd->bsize);
@@ -1058,7 +1022,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
leaf->lf_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
leaf->lf_header.mh_type = cpu_to_be32(GFS2_METATYPE_LF);
leaf->lf_header.mh_format = cpu_to_be32(GFS2_FORMAT_LF);
- leaf->lf_depth = cpu_to_be16(dip->i_di.di_depth - factor);
+ leaf->lf_depth = cpu_to_be16(dip->i_depth - factor);
/* initialize the first dirent on the new leaf block */
dent = (struct gfs2_dirent *)(nbh->b_data + sizeof(struct gfs2_leaf));
@@ -1074,10 +1038,9 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
cpyptr++;
}
pad_size = num_copies * sizeof(uint64_t);
- log_err(_("Writing to the hash table of directory %lld "
- "(0x%llx) at index: 0x%x for 0x%lx pointers.\n"),
- (unsigned long long)dip->i_di.di_num.no_addr,
- (unsigned long long)dip->i_di.di_num.no_addr,
+ log_err(_("Writing to the hash table of directory %"PRIu64
+ " (0x%"PRIx64") at index: 0x%x for 0x%lx pointers.\n"),
+ dip->i_addr, dip->i_addr,
start_lindex, (unsigned long)pad_size / sizeof(uint64_t));
if (dip->i_sbd->gfs1)
count = gfs1_writei(dip, padbuf, start_lindex *
@@ -1108,11 +1071,9 @@ static void pad_with_leafblks(struct gfs2_inode *ip, uint64_t *tbl,
uint32_t proper_start = lindex;
uint64_t new_leaf_blk;
- log_err(_("Padding inode %llu (0x%llx) hash table at offset %d (0x%x) "
- "for %d pointers.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr, lindex, lindex,
- len);
+ log_err(_("Padding inode %"PRIu64" (0x%"PRIx64") hash table at offset %d (0x%x) "
+ "for %d pointers.\n"),
+ ip->i_addr, ip->i_addr, lindex, lindex, len);
while (len) {
new_len = 1;
/* Determine the next factor of 2 down from extras. We can't
@@ -1205,6 +1166,7 @@ static int lost_leaf(struct gfs2_inode *ip, uint64_t *tbl, uint64_t leafno,
log_err(_("Not relocating corrupt entry "
"\"%s\".\n"), tmp_name);
} else {
+
error = dir_add(lf_dip, filename,
de.de_name_len, &de.de_inum,
de.de_type);
@@ -1220,10 +1182,13 @@ static int lost_leaf(struct gfs2_inode *ip, uint64_t *tbl, uint64_t leafno,
_("from lost+found"));
/* If it's a directory, lost+found is
back-linked to it via .. */
- if (isdir)
- incr_link_count(lf_dip->i_di.di_num,
- NULL,
- _("to lost+found"));
+ if (isdir) {
+ struct gfs2_inum no = {
+ .no_addr = lf_dip->i_addr,
+ .no_formal_ino = lf_dip->i_formal_ino
+ };
+ incr_link_count(no, NULL, _("to lost+found"));
+ }
log_err(_("Relocated \"%s\", block %llu "
"(0x%llx) to lost+found.\n"),
tmp_name,
@@ -1239,7 +1204,7 @@ static int lost_leaf(struct gfs2_inode *ip, uint64_t *tbl, uint64_t leafno,
"to lost+found.\n"));
/* Free the lost leaf. */
fsck_bitmap_set(ip, leafno, _("lost leaf"), GFS2_BLKST_FREE);
- ip->i_di.di_blocks--;
+ ip->i_blocks--;
bmodified(ip->i_bh);
/* Now we have to deal with the bad hash table entries pointing to the
misplaced leaf block. But we can't just fill the gap with a single
@@ -1300,12 +1265,8 @@ static int pass2_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no,
int new_leaf_blks = 0, error, refs;
uint64_t bn = 0;
- log_err( _("Directory Inode %llu (0x%llx) points to leaf %llu"
- " (0x%llx) %s.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)*leaf_no,
- (unsigned long long)*leaf_no, msg);
+ log_err(_("Directory Inode %"PRIu64" (0x%"PRIx64") points to leaf %"PRIu64" (0x%"PRIx64") %s.\n"),
+ ip->i_addr, ip->i_addr, *leaf_no, *leaf_no, msg);
if (!query( _("Attempt to patch around it? (y/n) "))) {
log_err( _("Bad leaf left in place.\n"));
goto out;
@@ -1329,9 +1290,8 @@ static int pass2_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no,
lindex += refs;
ref_count -= refs;
}
- log_err( _("Directory Inode %llu (0x%llx) repaired.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_err(_("Directory Inode %"PRIu64" (0x%"PRIx64") repaired.\n"),
+ ip->i_addr, ip->i_addr);
out:
*leaf_no = bn;
return new_leaf_blks;
@@ -1390,11 +1350,9 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize,
uint32_t leaf_proper_start;
*proper_len = len;
- log_err(_("Dinode %llu (0x%llx) has a hash table error at index "
- "0x%x, length 0x%x: leaf block %llu (0x%llx)\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr, lindex, len,
- (unsigned long long)leafblk, (unsigned long long)leafblk);
+ log_err(_("Dinode %"PRIu64" (0x%"PRIx64") has a hash table error at index "
+ "0x%x, length 0x%x: leaf block %"PRIu64" (0x%"PRIx64")\n"),
+ ip->i_addr, ip->i_addr, lindex, len, leafblk, leafblk);
if (!query( _("Fix the hash table? (y/n) "))) {
log_err(_("Hash table not fixed.\n"));
return 0;
@@ -1410,10 +1368,10 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize,
lbh = bread(ip->i_sbd, leafblk);
/* If the leaf's depth is out of range for this dinode, it's obviously
attached to the wrong dinode. Move the dirents to lost+found. */
- if (leaf.lf_depth > ip->i_di.di_depth) {
+ if (leaf.lf_depth > ip->i_depth) {
log_err(_("This leaf block's depth (%d) is too big for this "
"dinode's depth (%d)\n"),
- leaf.lf_depth, ip->i_di.di_depth);
+ leaf.lf_depth, ip->i_depth);
error = lost_leaf(ip, tbl, leafblk, len, lindex, lbh);
brelse(lbh);
return error;
@@ -1439,7 +1397,7 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize,
}
/* Calculate the proper number of pointers based on the leaf depth. */
- *proper_len = 1 << (ip->i_di.di_depth - leaf.lf_depth);
+ *proper_len = 1 << (ip->i_depth - leaf.lf_depth);
/* Look at the first dirent and check its hash value to see if it's
at the proper starting offset. */
@@ -1474,7 +1432,7 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize,
already at its maximum depth. */
if ((leaf_proper_start < proper_start) ||
((*proper_len > len || lindex > leaf_proper_start) &&
- leaf.lf_depth == ip->i_di.di_depth)) {
+ leaf.lf_depth == ip->i_depth)) {
log_err(_("Leaf block should start at 0x%x, but it appears at "
"0x%x in the hash table.\n"), leaf_proper_start,
proper_start);
@@ -1489,7 +1447,7 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize,
later than they should, we can split the leaf to give it a smaller
footprint in the hash table. */
if ((*proper_len > len || lindex > leaf_proper_start) &&
- ip->i_di.di_depth > leaf.lf_depth) {
+ ip->i_depth > leaf.lf_depth) {
log_err(_("For depth %d, length %d, the proper start is: "
"0x%x.\n"), factor, len, proper_start);
changes++;
@@ -1497,14 +1455,14 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize,
dir_split_leaf(ip, lindex, leafblk, lbh);
/* re-read the leaf to pick up dir_split_leaf's changes */
gfs2_leaf_in(&leaf, lbh->b_data);
- *proper_len = 1 << (ip->i_di.di_depth - leaf.lf_depth);
+ *proper_len = 1 << (ip->i_depth - leaf.lf_depth);
log_err(_("Leaf block %llu (0x%llx) was split from length "
"%d to %d\n"), (unsigned long long)leafblk,
(unsigned long long)leafblk, len, *proper_len);
if (*proper_len < 0) {
log_err(_("Programming error: proper_len=%d, "
"di_depth = %d, lf_depth = %d.\n"),
- *proper_len, ip->i_di.di_depth, leaf.lf_depth);
+ *proper_len, ip->i_depth, leaf.lf_depth);
exit(FSCK_ERROR);
}
log_err(_("New split-off leaf block was allocated at %lld "
@@ -1583,14 +1541,11 @@ static int check_hash_tbl_dups(struct gfs2_inode *ip, uint64_t *tbl,
if (be64_to_cpu(tbl[l + len2]) != leafblk)
break;
}
- log_err(_("Dinode %llu (0x%llx) has duplicate leaf pointers "
- "to block %llu (0x%llx) at offsets %u (0x%x) "
+ log_err(_("Dinode %"PRIu64" (0x%"PRIx64") has duplicate leaf pointers "
+ "to block %"PRIu64" (0x%"PRIx64") at offsets %u (0x%x) "
"(for 0x%x) and %u (0x%x) (for 0x%x)\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)leafblk,
- (unsigned long long)leafblk, lindex, lindex, len,
- l, l, len2);
+ ip->i_addr, ip->i_addr, leafblk, leafblk, lindex, lindex,
+ len, l, l, len2);
/* See which set of references is valid: the one passed in
or the duplicate we found. */
@@ -1624,7 +1579,7 @@ static int check_hash_tbl_dups(struct gfs2_inode *ip, uint64_t *tbl,
may have been correct without the duplicates but
pass1 would have counted them and adjusted the
count to include them. So we must subtract them. */
- ip->i_di.di_blocks--;
+ ip->i_blocks--;
bmodified(ip->i_bh);
pad_with_leafblks(ip, tbl, l, len2);
} else {
@@ -1644,7 +1599,7 @@ static int check_hash_tbl_dups(struct gfs2_inode *ip, uint64_t *tbl,
log_err(_("Hash table not fixed.\n"));
return 0;
}
- ip->i_di.di_blocks--;
+ ip->i_blocks--;
bmodified(ip->i_bh);
pad_with_leafblks(ip, tbl, lindex, len);
/* At this point we know both copies are bad, so we
@@ -1732,11 +1687,9 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
if (!valid_block_ip(ip, leafblk)) {
uint64_t new_leafblk;
- log_err(_("Dinode %llu (0x%llx) has bad leaf pointers "
+ log_err(_("Dinode %"PRIu64" (0x%"PRIx64") has bad leaf pointers "
"at offset %d for %d\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- lindex, len);
+ ip->i_addr, ip->i_addr, lindex, len);
if (!query( _("Fix the hash table? (y/n) "))) {
log_err(_("Hash table not fixed.\n"));
lindex += len;
@@ -1795,7 +1748,7 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
lbh = bread(ip->i_sbd, leafblk);
gfs2_leaf_in(&leaf, lbh->b_data);
if (gfs2_check_meta(lbh->b_data, GFS2_METATYPE_LF) ||
- leaf.lf_depth > ip->i_di.di_depth)
+ leaf.lf_depth > ip->i_depth)
leaf.lf_depth = factor;
brelse(lbh);
changes = fix_hashtable(ip, tbl, hsize, leafblk,
@@ -1820,10 +1773,9 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
if (be64_to_cpu(tbl[i]) == leafblk) /* No problem */
continue;
- log_err(_("Dinode %llu (0x%llx) has a hash table "
+ log_err(_("Dinode %"PRIu64" (0x%"PRIx64") has a hash table "
"inconsistency at index %d (0x%x) for %d\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
+ ip->i_addr, ip->i_addr,
i, i, len);
if (!query( _("Fix the hash table? (y/n) "))) {
log_err(_("Hash table not fixed.\n"));
@@ -1837,7 +1789,7 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
brelse(lbh);
/* Calculate the expected pointer count based on the
leaf depth. */
- proper_len = 1 << (ip->i_di.di_depth - leaf.lf_depth);
+ proper_len = 1 << (ip->i_depth - leaf.lf_depth);
if (proper_len != len) {
log_debug(_("Length 0x%x is not proper for "
"leaf %llu (0x%llx): 0x%x\n"),
@@ -1940,15 +1892,15 @@ static int check_pernode_for(int x, struct gfs2_inode *pernode, const char *fn,
return 0;
goto build_it;
}
- if (!ip->i_di.di_size)
+ if (!ip->i_size)
valid_size = 0;
- else if (!multiple && ip->i_di.di_size != filelen)
+ else if (!multiple && ip->i_size != filelen)
valid_size = 0;
- else if (multiple && (ip->i_di.di_size % filelen))
+ else if (multiple && (ip->i_size % filelen))
valid_size = 0;
if (!valid_size) {
log_err(_("System file %s has an invalid size. Is %"PRIu64", "
- "should be %llu.\n"), fn, ip->i_di.di_size, filelen);
+ "should be %llu.\n"), fn, ip->i_size, filelen);
if (!query( _("Rebuild the system file? (y/n) ")))
goto out_good;
fsck_inode_put(&ip);
@@ -1980,7 +1932,7 @@ build_it:
log_err(_("Error rebuilding %s.\n"), fn);
return -1;
}
- fsck_bitmap_set(ip, ip->i_di.di_num.no_addr, fn, GFS2_BLKST_DINODE);
+ fsck_bitmap_set(ip, ip->i_addr, fn, GFS2_BLKST_DINODE);
log_err(_("System file %s rebuilt.\n"), fn);
goto out_good;
}
@@ -2002,7 +1954,7 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
return -1;
}
- iblock = sysinode->i_di.di_num.no_addr;
+ iblock = sysinode->i_addr;
ds.q = bitmap_type(sysinode->i_sbd, iblock);
pass2_fxns.private = (void *) &ds;
@@ -2031,8 +1983,12 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
if (!ds.dotdir) {
log_err( _("No '.' entry found for %s directory.\n"), dirname);
if (query( _("Is it okay to add '.' entry? (y/n) "))) {
+ struct gfs2_inum no = {
+ .no_addr = sysinode->i_addr,
+ .no_formal_ino = sysinode->i_formal_ino
+ };
log_warn( _("Adding '.' entry\n"));
- error = dir_add(sysinode, ".", 1, &(sysinode->i_di.di_num),
+ error = dir_add(sysinode, ".", 1, &no,
(sysinode->i_sbd->gfs1 ? GFS_FILE_DIR : DT_DIR));
if (error) {
log_err(_("Error adding directory %s: %s\n"), "'.'",
@@ -2040,32 +1996,23 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
return -errno;
}
/* This system inode is linked to itself via '.' */
- incr_link_count(sysinode->i_di.di_num, sysinode,
- "sysinode \".\"");
+ incr_link_count(no, sysinode, "sysinode \".\"");
ds.entry_count++;
} else
log_err( _("The directory was not fixed.\n"));
}
- if (sysinode->i_di.di_entries != ds.entry_count) {
- log_err( _("%s inode %llu (0x%llx"
- "): Entries is %d - should be %d\n"), dirname,
- (unsigned long long)sysinode->i_di.di_num.no_addr,
- (unsigned long long)sysinode->i_di.di_num.no_addr,
- sysinode->i_di.di_entries, ds.entry_count);
- if (query( _("Fix entries for %s inode %llu (0x%llx)? (y/n) "),
- dirname,
- (unsigned long long)sysinode->i_di.di_num.no_addr,
- (unsigned long long)sysinode->i_di.di_num.no_addr)) {
- sysinode->i_di.di_entries = ds.entry_count;
+ if (sysinode->i_entries != ds.entry_count) {
+ log_err(_("%s inode %"PRIu64" (0x%"PRIx64"): Entries is %d - should be %d\n"),
+ dirname, sysinode->i_addr, sysinode->i_addr, sysinode->i_entries,
+ ds.entry_count);
+ if (query( _("Fix entries for %s inode %"PRIu64" (0x%"PRIx64")? (y/n) "),
+ dirname, sysinode->i_addr, sysinode->i_addr)) {
+ sysinode->i_entries = ds.entry_count;
bmodified(sysinode->i_bh);
log_warn( _("Entries updated\n"));
} else {
- log_err( _("Entries for inode %llu (0x%llx"
- ") left out of sync\n"),
- (unsigned long long)
- sysinode->i_di.di_num.no_addr,
- (unsigned long long)
- sysinode->i_di.di_num.no_addr);
+ log_err(_("Entries for inode %"PRIu64" (0x%"PRIx64") left out of sync\n"),
+ sysinode->i_addr, sysinode->i_addr);
}
}
error = 0;
@@ -2095,20 +2042,20 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
*/
static inline int is_system_dir(struct gfs2_sbd *sdp, uint64_t block)
{
- if (block == sdp->md.rooti->i_di.di_num.no_addr)
+ if (block == sdp->md.rooti->i_addr)
return 1;
if (sdp->gfs1)
return 0;
- if (block == sdp->md.jiinode->i_di.di_num.no_addr ||
- block == sdp->md.pinode->i_di.di_num.no_addr ||
- block == sdp->master_dir->i_di.di_num.no_addr)
+ if (block == sdp->md.jiinode->i_addr ||
+ block == sdp->md.pinode->i_addr ||
+ block == sdp->master_dir->i_addr)
return 1;
return 0;
}
static int pass2_check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
{
- uint64_t dirblk = ip->i_di.di_num.no_addr;
+ uint64_t dirblk = ip->i_addr;
struct dir_status ds = {0};
int error;
@@ -2161,7 +2108,11 @@ static int pass2_check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
(unsigned long long)dirblk, (unsigned long long)dirblk);
if (query( _("Is it okay to add '.' entry? (y/n) "))) {
- error = dir_add(ip, ".", 1, &(ip->i_di.di_num),
+ struct gfs2_inum no = {
+ .no_addr = ip->i_addr,
+ .no_formal_ino = ip->i_formal_ino
+ };
+ error = dir_add(ip, ".", 1, &no,
(sdp->gfs1 ? GFS_FILE_DIR : DT_DIR));
if (error) {
log_err(_("Error adding directory %s: %s\n"), "'.'",
@@ -2169,7 +2120,7 @@ static int pass2_check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
return -errno;
}
/* directory links to itself via '.' */
- incr_link_count(ip->i_di.di_num, ip, _("\". (itself)\""));
+ incr_link_count(no, ip, _("\". (itself)\""));
ds.entry_count++;
log_err(_("The directory was fixed.\n"));
} else {
@@ -2177,13 +2128,11 @@ static int pass2_check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
}
}
- if (!fsck_abort && ip->i_di.di_entries != ds.entry_count) {
- log_err(_("Entries is %d - should be %d for inode block %llu (0x%llx)\n"),
- ip->i_di.di_entries, ds.entry_count,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ if (!fsck_abort && ip->i_entries != ds.entry_count) {
+ log_err(_("Entries is %d - should be %d for inode block %"PRIu64" (0x%"PRIx64")\n"),
+ ip->i_entries, ds.entry_count, ip->i_addr, ip->i_addr);
if (query(_("Fix the entry count? (y/n) "))) {
- ip->i_di.di_entries = ds.entry_count;
+ ip->i_entries = ds.entry_count;
bmodified(ip->i_bh);
} else {
log_err(_("The entry count was not fixed.\n"));
@@ -2256,8 +2205,7 @@ int pass2(struct gfs2_sbd *sdp)
/* If we created lost+found, its links should have been
properly adjusted, so don't check it. */
- if (lf_was_created &&
- (dirblk == lf_dip->i_di.di_num.no_addr)) {
+ if (lf_was_created && (dirblk == lf_dip->i_addr)) {
log_debug(_("Pass2 skipping the new lost+found.\n"));
continue;
}
diff --git a/gfs2/fsck/pass3.c b/gfs2/fsck/pass3.c
index 4b9c54d8..8b8b19bc 100644
--- a/gfs2/fsck/pass3.c
+++ b/gfs2/fsck/pass3.c
@@ -25,6 +25,7 @@ static int attach_dotdot_to(struct gfs2_sbd *sdp, uint64_t newdotdot,
int filename_len = 2;
int err;
struct gfs2_inode *ip, *pip;
+ struct gfs2_inum no;
ip = fsck_load_inode(sdp, block);
pip = fsck_load_inode(sdp, newdotdot);
@@ -39,14 +40,16 @@ static int attach_dotdot_to(struct gfs2_sbd *sdp, uint64_t newdotdot,
log_warn( _("Unable to remove \"..\" directory entry.\n"));
else
decr_link_count(olddotdot, block, sdp->gfs1, _("old \"..\""));
- err = dir_add(ip, filename, filename_len, &pip->i_di.di_num,
+ no.no_addr = pip->i_addr;
+ no.no_formal_ino = pip->i_formal_ino;
+ err = dir_add(ip, filename, filename_len, &no,
(sdp->gfs1 ? GFS_FILE_DIR : DT_DIR));
if (err) {
log_err(_("Error adding directory %s: %s\n"),
filename, strerror(errno));
exit(FSCK_ERROR);
}
- incr_link_count(pip->i_di.di_num, ip, _("new \"..\""));
+ incr_link_count(no, ip, _("new \"..\""));
fsck_inode_put(&ip);
fsck_inode_put(&pip);
return 0;
@@ -174,38 +177,38 @@ int pass3(struct gfs2_sbd *sdp)
struct gfs2_inode *ip;
int q;
- di = dirtree_find(sdp->md.rooti->i_di.di_num.no_addr);
+ di = dirtree_find(sdp->md.rooti->i_addr);
if (di) {
log_info( _("Marking root inode connected\n"));
di->checked = 1;
}
if (sdp->gfs1) {
- di = dirtree_find(sdp->md.statfs->i_di.di_num.no_addr);
+ di = dirtree_find(sdp->md.statfs->i_addr);
if (di) {
log_info( _("Marking GFS1 statfs file inode "
"connected\n"));
di->checked = 1;
}
- di = dirtree_find(sdp->md.jiinode->i_di.di_num.no_addr);
+ di = dirtree_find(sdp->md.jiinode->i_addr);
if (di) {
log_info( _("Marking GFS1 jindex file inode "
"connected\n"));
di->checked = 1;
}
- di = dirtree_find(sdp->md.riinode->i_di.di_num.no_addr);
+ di = dirtree_find(sdp->md.riinode->i_addr);
if (di) {
log_info( _("Marking GFS1 rindex file inode "
"connected\n"));
di->checked = 1;
}
- di = dirtree_find(sdp->md.qinode->i_di.di_num.no_addr);
+ di = dirtree_find(sdp->md.qinode->i_addr);
if (di) {
log_info( _("Marking GFS1 quota file inode "
"connected\n"));
di->checked = 1;
}
} else {
- di = dirtree_find(sdp->master_dir->i_di.di_num.no_addr);
+ di = dirtree_find(sdp->master_dir->i_addr);
if (di) {
log_info( _("Marking master directory inode "
"connected\n"));
@@ -288,7 +291,7 @@ int pass3(struct gfs2_sbd *sdp)
(unsigned long long)di->dinode.no_addr,
(unsigned long long)di->dinode.no_addr);
/* Don't skip zero size directories with eattrs */
- if (!ip->i_di.di_size && !ip->i_di.di_eattr){
+ if (!ip->i_size && !ip->i_eattr){
log_err( _("Unlinked directory has zero "
"size.\n"));
if (query( _("Remove zero-size unlinked "
@@ -320,7 +323,7 @@ int pass3(struct gfs2_sbd *sdp)
}
if (lf_dip) {
log_debug( _("At end of pass3, lost+found entries is %u\n"),
- lf_dip->i_di.di_entries);
+ lf_dip->i_entries);
}
return FSCK_OK;
}
diff --git a/gfs2/fsck/pass4.c b/gfs2/fsck/pass4.c
index 313ff0fb..42892da1 100644
--- a/gfs2/fsck/pass4.c
+++ b/gfs2/fsck/pass4.c
@@ -28,18 +28,15 @@ struct metawalk_fxns pass4_fxns_delete = {
* link count */
static int fix_link_count(uint32_t counted_links, struct gfs2_inode *ip)
{
- log_info( _("Fixing inode link count (%d->%d) for %llu (0x%llx) \n"),
- ip->i_di.di_nlink, counted_links,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
- if (ip->i_di.di_nlink == counted_links)
+ log_info(_("Fixing inode link count (%d->%d) for %"PRIu64" (0x%"PRIx64") \n"),
+ ip->i_nlink, counted_links, ip->i_addr, ip->i_addr);
+ if (ip->i_nlink == counted_links)
return 0;
- ip->i_di.di_nlink = counted_links;
+ ip->i_nlink = counted_links;
bmodified(ip->i_bh);
- log_debug( _("Changing inode %llu (0x%llx) to have %u links\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr, counted_links);
+ log_debug(_("Changing inode %"PRIu64" (0x%"PRIx64") to have %u links\n"),
+ ip->i_addr, ip->i_addr, counted_links);
return 0;
}
@@ -102,7 +99,7 @@ static int handle_unlinked(struct gfs2_sbd *sdp, uint64_t no_addr,
/* We don't want to clear zero-size files with eattrs - there might be
relevent info in them. */
- if (!ip->i_di.di_size && !ip->i_di.di_eattr){
+ if (!ip->i_size && !ip->i_eattr){
log_err( _("Unlinked inode has zero size\n"));
if (query(_("Clear zero-size unlinked inode? (y/n) "))) {
fsck_bitmap_set(ip, no_addr, _("unlinked zero-length"),
@@ -164,7 +161,7 @@ static int adjust_lf_links(int lf_addition)
if (!lf_addition)
return 0;
- if (!(lf_di = dirtree_find(lf_dip->i_di.di_num.no_addr))) {
+ if (!(lf_di = dirtree_find(lf_dip->i_addr))) {
log_crit(_("Unable to find lost+found inode in "
"inode_hash!!\n"));
return -1;
@@ -189,9 +186,9 @@ static int scan_inode_list(struct gfs2_sbd *sdp)
ii = (struct inode_info *)tmp;
/* Don't check reference counts on the special gfs files */
if (sdp->gfs1 &&
- ((ii->di_num.no_addr == sdp->md.riinode->i_di.di_num.no_addr) ||
- (ii->di_num.no_addr == sdp->md.qinode->i_di.di_num.no_addr) ||
- (ii->di_num.no_addr == sdp->md.statfs->i_di.di_num.no_addr)))
+ ((ii->di_num.no_addr == sdp->md.riinode->i_addr) ||
+ (ii->di_num.no_addr == sdp->md.qinode->i_addr) ||
+ (ii->di_num.no_addr == sdp->md.statfs->i_addr)))
continue;
if (ii->counted_links == 0) {
if (handle_unlinked(sdp, ii->di_num.no_addr,
@@ -225,7 +222,7 @@ static int scan_dir_list(struct gfs2_sbd *sdp)
di = (struct dir_info *)tmp;
/* Don't check reference counts on the special gfs files */
if (sdp->gfs1 &&
- di->dinode.no_addr == sdp->md.jiinode->i_di.di_num.no_addr)
+ di->dinode.no_addr == sdp->md.jiinode->i_addr)
continue;
if (di->counted_links == 0) {
if (handle_unlinked(sdp, di->dinode.no_addr,
@@ -282,7 +279,7 @@ int pass4(struct gfs2_sbd *sdp)
{
if (lf_dip)
log_debug( _("At beginning of pass4, lost+found entries is %u\n"),
- lf_dip->i_di.di_entries);
+ lf_dip->i_entries);
log_info( _("Checking inode reference counts: multi-links.\n"));
if (scan_inode_list(sdp)) {
stack;
@@ -301,6 +298,6 @@ int pass4(struct gfs2_sbd *sdp)
if (lf_dip)
log_debug( _("At end of pass4, lost+found entries is %u\n"),
- lf_dip->i_di.di_entries);
+ lf_dip->i_entries);
return FSCK_OK;
}
diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c
index bf1641e8..316be67c 100644
--- a/gfs2/fsck/rgrepair.c
+++ b/gfs2/fsck/rgrepair.c
@@ -60,10 +60,9 @@ static void find_journaled_rgs(struct gfs2_sbd *sdp)
osi_list_init(&false_rgrps.list);
for (j = 0; j < sdp->md.journals; j++) {
ip = sdp->md.journal[j];
- log_debug(_("Checking for rgrps in journal%d which starts "
- "at block 0x%llx.\n"), j,
- (unsigned long long)ip->i_di.di_num.no_addr);
- jblocks = ip->i_di.di_size / sdp->sd_sb.sb_bsize;
+ log_debug(_("Checking for rgrps in journal%d which starts at block 0x%"PRIx64".\n"),
+ j, ip->i_addr);
+ jblocks = ip->i_size / sdp->sd_sb.sb_bsize;
false_count = 0;
for (b = 0; b < jblocks; b++) {
block_map(ip, b, &new, &dblock, NULL, 0);
@@ -876,7 +875,7 @@ static int gfs2_rindex_calculate(struct gfs2_sbd *sdp, int *num_rgs)
/* our rindex structures, then something's wrong and we can't trust */
/* the index. */
/* ----------------------------------------------------------------- */
- *num_rgs = sdp->md.riinode->i_di.di_size / sizeof(struct gfs2_rindex);
+ *num_rgs = sdp->md.riinode->i_size / sizeof(struct gfs2_rindex);
sdp->rgcalc.osi_node = NULL;
fix_device_geometry(sdp);
@@ -979,7 +978,7 @@ static int expect_rindex_sanity(struct gfs2_sbd *sdp, int *num_rgs)
struct osi_node *n, *next = NULL;
struct rgrp_tree *rgd, *exp;
- *num_rgs = sdp->md.riinode->i_di.di_size / sizeof(struct gfs2_rindex) ;
+ *num_rgs = sdp->md.riinode->i_size / sizeof(struct gfs2_rindex) ;
for (n = osi_first(&sdp->rgtree); n; n = next) {
next = osi_next(n);
rgd = (struct rgrp_tree *)n;
@@ -1067,7 +1066,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok)
/* Read in the rindex */
sdp->rgtree.osi_node = NULL; /* Just to be safe */
rindex_read(sdp, &sdp->rgrps, ok);
- if (sdp->md.riinode->i_di.di_size % sizeof(struct gfs2_rindex)) {
+ if (sdp->md.riinode->i_size % sizeof(struct gfs2_rindex)) {
log_warn( _("WARNING: rindex file has an invalid size.\n"));
if (!query( _("Truncate the rindex size? (y/n)"))) {
log_err(_("The rindex was not repaired.\n"));
@@ -1075,11 +1074,10 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok)
gfs2_rgrp_free(sdp, &sdp->rgtree);
return -1;
}
- sdp->md.riinode->i_di.di_size /= sizeof(struct gfs2_rindex);
- sdp->md.riinode->i_di.di_size *= sizeof(struct gfs2_rindex);
+ sdp->md.riinode->i_size /= sizeof(struct gfs2_rindex);
+ sdp->md.riinode->i_size *= sizeof(struct gfs2_rindex);
bmodified(sdp->md.riinode->i_bh);
- log_err(_("Changing rindex size to %lld.\n"),
- (unsigned long long)sdp->md.riinode->i_di.di_size);
+ log_err(_("Changing rindex size to %"PRIu64".\n"), sdp->md.riinode->i_size);
}
log_warn( _("L%d: number of rgs expected = %lld.\n"), trust_lvl + 1,
(unsigned long long)sdp->rgrps);
@@ -1104,8 +1102,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok)
/* We cannot grow rindex at this point. Since pass1 has not
yet run, we can't allocate blocks. Therefore we must use
whatever will fix in the space given. */
- most_that_fit = sdp->md.riinode->i_di.di_size /
- sizeof(struct gfs2_rindex);
+ most_that_fit = sdp->md.riinode->i_size / sizeof(struct gfs2_rindex);
log_debug(_("The most we can fit is %d rgrps\n"),
most_that_fit);
if (most_that_fit < calc_rg_count)
@@ -1281,7 +1278,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok)
permission. */
if (sdp->md.riinode->i_bh->b_modified) {
log_debug("Syncing rindex inode changes to disk.\n");
- gfs2_dinode_out(&sdp->md.riinode->i_di, sdp->md.riinode->i_bh->b_data);
+ lgfs2_dinode_out(sdp->md.riinode, sdp->md.riinode->i_bh->b_data);
bwrite(sdp->md.riinode->i_bh);
}
return 0;
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index 26170fa5..84022814 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -30,7 +30,7 @@ void big_file_comfort(struct gfs2_inode *ip, uint64_t blks_checked)
int i, cs;
const char *human_abbrev = " KMGTPE";
- one_percent = ip->i_di.di_blocks / 100;
+ one_percent = ip->i_blocks / 100;
if (blks_checked - last_reported_fblock < one_percent)
return;
@@ -41,21 +41,17 @@ void big_file_comfort(struct gfs2_inode *ip, uint64_t blks_checked)
if (tv.tv_sec == seconds)
return;
- fsize = ip->i_di.di_size;
+ fsize = ip->i_size;
for (i = 0; i < 6 && fsize > 1024; i++)
fsize /= 1024;
chksize = blks_checked * ip->i_sbd->bsize;
for (cs = 0; cs < 6 && chksize > 1024; cs++)
chksize /= 1024;
seconds = tv.tv_sec;
- percent = (blks_checked * 100) / ip->i_di.di_blocks;
- log_notice( _("\rChecking %lld%c of %lld%c of file at %lld (0x%llx)"
- "- %llu percent complete. \r"),
- (long long)chksize, human_abbrev[cs],
- (unsigned long long)fsize, human_abbrev[i],
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)percent);
+ percent = (blks_checked * 100) / ip->i_blocks;
+ log_notice(_("\rChecking %"PRIu64"%c of %"PRIu64"%c of file at %"PRIu64" (0x%"PRIx64")"
+ "- %"PRIu64" percent complete. \r"),
+ chksize, human_abbrev[cs], fsize, human_abbrev[i], ip->i_addr, ip->i_addr, percent);
fflush(stdout);
}
@@ -281,13 +277,13 @@ struct inode_with_dups *find_dup_ref_inode(struct duptree *dt,
osi_list_foreach(ref, &dt->ref_invinode_list) {
id = osi_list_entry(ref, struct inode_with_dups, list);
- if (id->block_no == ip->i_di.di_num.no_addr)
+ if (id->block_no == ip->i_addr)
return id;
}
osi_list_foreach(ref, &dt->ref_inode_list) {
id = osi_list_entry(ref, struct inode_with_dups, list);
- if (id->block_no == ip->i_di.di_num.no_addr)
+ if (id->block_no == ip->i_addr)
return id;
}
return NULL;
@@ -365,10 +361,9 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block,
"a duplicate within the same inode.\n"),
(unsigned long long)block,
(unsigned long long)block);
- log_info(_("I'll consider the reference from inode %llu "
- "(0x%llx) the first reference.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_info(_("I'll consider the reference from inode %"PRIu64
+ " (0x%"PRIx64") the first reference.\n"),
+ ip->i_addr, ip->i_addr);
dt->dup_flags |= DUPFLAG_REF1_IS_DUPL;
dt->refs++;
}
@@ -393,8 +388,8 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block,
log_crit( _("Unable to allocate inode_with_dups structure\n"));
return META_ERROR;
}
- id->block_no = ip->i_di.di_num.no_addr;
- q = bitmap_type(ip->i_sbd, ip->i_di.di_num.no_addr);
+ id->block_no = ip->i_addr;
+ q = bitmap_type(ip->i_sbd, ip->i_addr);
/* If it's an invalid dinode, put it first on the invalid
inode reference list otherwise put it on the normal list. */
if (!inode_valid || q == GFS2_BLKST_UNLINKED)
@@ -414,13 +409,11 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block,
}
id->reftypecount[reftype]++;
id->dup_count++;
- log_info( _("Found %d reference(s) to block %llu"
- " (0x%llx) as %s in %s inode #%llu (0x%llx)\n"),
- id->dup_count, (unsigned long long)block,
- (unsigned long long)block, reftypes[reftype],
+ log_info(_("Found %d reference(s) to block %"PRIu64" (0x%"PRIx64") "
+ "as %s in %s inode #%"PRIu64" (0x%"PRIx64")\n"),
+ id->dup_count, block, block, reftypes[reftype],
inode_valid ? _("valid") : _("invalid"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ ip->i_addr, ip->i_addr);
if (first)
log_info( _("This is the original reference.\n"));
else {
@@ -587,7 +580,7 @@ uint64_t find_free_blk(struct gfs2_sbd *sdp)
uint64_t *get_dir_hash(struct gfs2_inode *ip)
{
- unsigned hsize = (1 << ip->i_di.di_depth) * sizeof(uint64_t);
+ unsigned hsize = (1 << ip->i_depth) * sizeof(uint64_t);
int ret;
uint64_t *tbl = malloc(hsize);
@@ -620,14 +613,14 @@ void delete_all_dups(struct gfs2_inode *ip)
osi_list_foreach_safe(tmp, &dt->ref_invinode_list, x) {
id = osi_list_entry(tmp, struct inode_with_dups, list);
- if (id->block_no == ip->i_di.di_num.no_addr) {
+ if (id->block_no == ip->i_addr) {
dup_listent_delete(dt, id);
found = 1;
}
}
osi_list_foreach_safe(tmp, &dt->ref_inode_list, x) {
id = osi_list_entry(tmp, struct inode_with_dups, list);
- if (id->block_no == ip->i_di.di_num.no_addr) {
+ if (id->block_no == ip->i_addr) {
dup_listent_delete(dt, id);
found = 1;
}
diff --git a/gfs2/fsck/util.h b/gfs2/fsck/util.h
index d8767247..182868a6 100644
--- a/gfs2/fsck/util.h
+++ b/gfs2/fsck/util.h
@@ -83,11 +83,11 @@ static const inline char *block_type_string(int q)
return blktyp[4];
}
-static inline int is_dir(struct gfs2_dinode *dinode, int gfs1)
+static inline int is_dir(struct gfs2_inode *ip, int gfs1)
{
- if (gfs1 && is_gfs_dir(dinode))
+ if (gfs1 && is_gfs_dir(ip))
return 1;
- if (S_ISDIR(dinode->di_mode))
+ if (S_ISDIR(ip->i_mode))
return 1;
return 0;
@@ -95,7 +95,7 @@ static inline int is_dir(struct gfs2_dinode *dinode, int gfs1)
static inline uint32_t gfs_to_gfs2_mode(struct gfs2_inode *ip)
{
- uint16_t gfs1mode = ip->i_di.__pad1;
+ uint16_t gfs1mode = ip->i_pad1;
switch (gfs1mode) {
case GFS_FILE_DIR:
@@ -114,8 +114,8 @@ static inline uint32_t gfs_to_gfs2_mode(struct gfs2_inode *ip)
return S_IFSOCK;
default:
/* This could be an aborted gfs2_convert so look for both. */
- if (ip->i_di.di_entries ||
- (ip->i_di.di_mode & S_IFMT) == S_IFDIR)
+ if (ip->i_entries ||
+ (ip->i_mode & S_IFMT) == S_IFDIR)
return S_IFDIR;
else
return S_IFREG;
diff --git a/gfs2/glocktop/glocktop.c b/gfs2/glocktop/glocktop.c
index 0096a2a5..c0fc0ceb 100644
--- a/gfs2/glocktop/glocktop.c
+++ b/gfs2/glocktop/glocktop.c
@@ -621,7 +621,7 @@ static const char *show_inode(const char *id, int fd, unsigned long long block)
struct gfs2_sbd sbd = { .device_fd = fd, .bsize = bsize };
ip = lgfs2_inode_read(&sbd, block);
- if (S_ISDIR(ip->i_di.di_mode)) {
+ if (S_ISDIR(ip->i_mode)) {
struct gfs2_inode *parent;
unsigned long long dirarray[256];
int subdepth = 0, error;
@@ -635,27 +635,26 @@ static const char *show_inode(const char *id, int fd, unsigned long long block)
if (error)
break;
/* Stop at the root inode */
- if (ip->i_di.di_num.no_addr ==
- parent->i_di.di_num.no_addr) {
+ if (ip->i_addr == parent->i_addr) {
inode_put(&parent);
break;
}
inode_put(&ip);
ip = parent;
- dirarray[subdepth++] = parent->i_di.di_num.no_addr;
+ dirarray[subdepth++] = parent->i_addr;
}
display_filename(fd, block, dirarray, subdepth);
- } else if (S_ISREG(ip->i_di.di_mode)) {
+ } else if (S_ISREG(ip->i_mode)) {
inode_type = "file ";
- } else if (S_ISLNK(ip->i_di.di_mode)) {
+ } else if (S_ISLNK(ip->i_mode)) {
inode_type = "link ";
- } else if (S_ISCHR(ip->i_di.di_mode)) {
+ } else if (S_ISCHR(ip->i_mode)) {
inode_type = "char device ";
- } else if (S_ISBLK(ip->i_di.di_mode)) {
+ } else if (S_ISBLK(ip->i_mode)) {
inode_type = "block device ";
- } else if (S_ISFIFO(ip->i_di.di_mode)) {
+ } else if (S_ISFIFO(ip->i_mode)) {
inode_type = "fifo ";
- } else if (S_ISSOCK(ip->i_di.di_mode)) {
+ } else if (S_ISSOCK(ip->i_mode)) {
inode_type = "socket ";
} else
inode_type = "file? ";
diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index 12d845f1..ccb75df3 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
@@ -27,7 +27,7 @@ static __inline__ uint64_t *metapointer(char *buf,
/* Detect directory is a stuffed inode */
static int inode_is_stuffed(const struct gfs2_inode *ip)
{
- return !ip->i_di.di_height;
+ return !ip->i_height;
}
struct gfs2_inode *lgfs2_inode_get(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh)
@@ -38,7 +38,7 @@ struct gfs2_inode *lgfs2_inode_get(struct gfs2_sbd *sdp, struct gfs2_buffer_head
if (ip == NULL) {
return NULL;
}
- gfs2_dinode_in(&ip->i_di, bh->b_data);
+ lgfs2_dinode_in(ip, bh->b_data);
ip->i_bh = bh;
ip->i_sbd = sdp;
return ip;
@@ -64,25 +64,25 @@ struct gfs2_inode *is_system_inode(struct gfs2_sbd *sdp, uint64_t block)
{
int j;
- if (sdp->md.inum && block == sdp->md.inum->i_di.di_num.no_addr)
+ if (sdp->md.inum && block == sdp->md.inum->i_addr)
return sdp->md.inum;
- if (sdp->md.statfs && block == sdp->md.statfs->i_di.di_num.no_addr)
+ if (sdp->md.statfs && block == sdp->md.statfs->i_addr)
return sdp->md.statfs;
- if (sdp->md.jiinode && block == sdp->md.jiinode->i_di.di_num.no_addr)
+ if (sdp->md.jiinode && block == sdp->md.jiinode->i_addr)
return sdp->md.jiinode;
- if (sdp->md.riinode && block == sdp->md.riinode->i_di.di_num.no_addr)
+ if (sdp->md.riinode && block == sdp->md.riinode->i_addr)
return sdp->md.riinode;
- if (sdp->md.qinode && block == sdp->md.qinode->i_di.di_num.no_addr)
+ if (sdp->md.qinode && block == sdp->md.qinode->i_addr)
return sdp->md.qinode;
- if (sdp->md.pinode && block == sdp->md.pinode->i_di.di_num.no_addr)
+ if (sdp->md.pinode && block == sdp->md.pinode->i_addr)
return sdp->md.pinode;
- if (sdp->md.rooti && block == sdp->md.rooti->i_di.di_num.no_addr)
+ if (sdp->md.rooti && block == sdp->md.rooti->i_addr)
return sdp->md.rooti;
- if (sdp->master_dir && block == sdp->master_dir->i_di.di_num.no_addr)
+ if (sdp->master_dir && block == sdp->master_dir->i_addr)
return sdp->master_dir;
for (j = 0; j < sdp->md.journals; j++)
if (sdp->md.journal && sdp->md.journal[j] &&
- block == sdp->md.journal[j]->i_di.di_num.no_addr)
+ block == sdp->md.journal[j]->i_addr)
return sdp->md.journal[j];
return NULL;
}
@@ -90,11 +90,11 @@ struct gfs2_inode *is_system_inode(struct gfs2_sbd *sdp, uint64_t block)
void inode_put(struct gfs2_inode **ip_in)
{
struct gfs2_inode *ip = *ip_in;
- uint64_t block = ip->i_di.di_num.no_addr;
+ uint64_t block = ip->i_addr;
struct gfs2_sbd *sdp = ip->i_sbd;
if (ip->i_bh->b_modified) {
- gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data);
+ lgfs2_dinode_out(ip, ip->i_bh->b_data);
if (!ip->bh_owned && is_system_inode(sdp, block))
fprintf(stderr, "Warning: Change made to inode "
"were discarded.\n");
@@ -212,7 +212,7 @@ int lgfs2_meta_alloc(struct gfs2_inode *ip, uint64_t *blkno)
ip->i_sbd->gfs1 ? GFS2_BLKST_DINODE :
GFS2_BLKST_USED, blkno, 0);
if (ret == 0) {
- ip->i_di.di_goal_meta = *blkno;
+ ip->i_goal_meta = *blkno;
bmodified(ip->i_bh);
}
return ret;
@@ -242,9 +242,9 @@ void unstuff_dinode(struct gfs2_inode *ip)
struct gfs2_sbd *sdp = ip->i_sbd;
struct gfs2_buffer_head *bh;
uint64_t block = 0;
- int isdir = S_ISDIR(ip->i_di.di_mode) || is_gfs_dir(&ip->i_di);
+ int isdir = S_ISDIR(ip->i_mode) || is_gfs_dir(ip);
- if (ip->i_di.di_size) {
+ if (ip->i_size) {
if (lgfs2_meta_alloc(ip, &block))
exit(1);
if (isdir) {
@@ -273,13 +273,13 @@ void unstuff_dinode(struct gfs2_inode *ip)
buffer_clear_tail(sdp, ip->i_bh, sizeof(struct gfs2_dinode));
- if (ip->i_di.di_size) {
+ if (ip->i_size) {
*(uint64_t *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode)) = cpu_to_be64(block);
/* no need: bmodified(ip->i_bh); buffer_clear_tail does it */
- ip->i_di.di_blocks++;
+ ip->i_blocks++;
}
- ip->i_di.di_height = 1;
+ ip->i_height = 1;
}
/**
@@ -305,7 +305,7 @@ uint64_t lgfs2_space_for_data(const struct gfs2_sbd *sdp, const unsigned bsize,
* rg: The resource group in which to allocate the extent
* di_size: The size of the file in bytes
* ip: A pointer to the inode structure, whose fields will be set appropriately.
- * If ip->i_di.di_num.no_addr is not 0, the extent search will be skipped and
+ * If ip->i_num.no_addr is not 0, the extent search will be skipped and
* the file allocated from that address.
* flags: GFS2_DIF_* flags
* mode: File mode flags, see creat(2)
@@ -316,13 +316,12 @@ uint64_t lgfs2_space_for_data(const struct gfs2_sbd *sdp, const unsigned bsize,
int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct gfs2_inode *ip, uint32_t flags, unsigned mode)
{
unsigned extlen;
- struct gfs2_dinode *di = &ip->i_di;
struct gfs2_sbd *sdp = rg->rgrps->sdp;
struct lgfs2_rbm rbm = { .rgd = rg, .offset = 0, .bii = 0 };
uint32_t blocks = lgfs2_space_for_data(sdp, sdp->bsize, di_size);
- if (ip->i_di.di_num.no_addr != 0) {
- if (lgfs2_rbm_from_block(&rbm, ip->i_di.di_num.no_addr) != 0)
+ if (ip->i_addr != 0) {
+ if (lgfs2_rbm_from_block(&rbm, ip->i_addr) != 0)
return 1;
} else if (lgfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &blocks) != 0) {
return 1;
@@ -336,20 +335,20 @@ int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct gfs2_inode *ip, u
ip->i_sbd = sdp;
- di->di_header.mh_magic = GFS2_MAGIC;
- di->di_header.mh_type = GFS2_METATYPE_DI;
- di->di_header.mh_format = GFS2_FORMAT_DI;
- di->di_size = di_size;
- di->di_num.no_addr = lgfs2_rbm_to_block(&rbm);
- di->di_num.no_formal_ino = sdp->md.next_inum++;
- di->di_mode = mode;
- di->di_nlink = 1;
- di->di_blocks = blocks;
- di->di_atime = di->di_mtime = di->di_ctime = sdp->time;
- di->di_goal_data = di->di_num.no_addr + di->di_blocks - 1;
- di->di_goal_meta = di->di_goal_data - ((di_size + sdp->bsize - 1) / sdp->bsize);
- di->di_height = calc_tree_height(ip, di_size);
- di->di_flags = flags;
+ ip->i_magic = GFS2_MAGIC;
+ ip->i_type = GFS2_METATYPE_DI;
+ ip->i_format = GFS2_FORMAT_DI;
+ ip->i_size = di_size;
+ ip->i_addr = lgfs2_rbm_to_block(&rbm);
+ ip->i_formal_ino = sdp->md.next_inum++;
+ ip->i_mode = mode;
+ ip->i_nlink = 1;
+ ip->i_blocks = blocks;
+ ip->i_atime = ip->i_mtime = ip->i_ctime = sdp->time;
+ ip->i_goal_data = ip->i_addr + ip->i_blocks - 1;
+ ip->i_goal_meta = ip->i_goal_data - ((di_size + sdp->bsize - 1) / sdp->bsize);
+ ip->i_height = calc_tree_height(ip, di_size);
+ ip->i_flags = flags;
rg->rg.rg_free -= blocks;
rg->rg.rg_dinodes += 1;
@@ -366,10 +365,10 @@ unsigned int calc_tree_height(struct gfs2_inode *ip, uint64_t size)
uint64_t *arr;
unsigned int max, height;
- if (ip->i_di.di_size > size)
- size = ip->i_di.di_size;
+ if (ip->i_size > size)
+ size = ip->i_size;
- if (S_ISDIR(ip->i_di.di_mode)) {
+ if (S_ISDIR(ip->i_mode)) {
arr = sdp->sd_jheightsize;
max = sdp->sd_max_jheight;
} else {
@@ -392,7 +391,7 @@ void build_height(struct gfs2_inode *ip, int height)
unsigned int x;
int new_block;
- while (ip->i_di.di_height < height) {
+ while (ip->i_height < height) {
new_block = 0;
bp = (uint64_t *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode));
for (x = 0; x < sdp->sd_diptrs; x++, bp++)
@@ -423,17 +422,17 @@ void build_height(struct gfs2_inode *ip, int height)
if (new_block) {
*(uint64_t *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode)) = cpu_to_be64(block);
/* no need: bmodified(ip->i_bh);*/
- ip->i_di.di_blocks++;
+ ip->i_blocks++;
}
- ip->i_di.di_height++;
+ ip->i_height++;
}
}
void find_metapath(struct gfs2_inode *ip, uint64_t block, struct metapath *mp)
{
const uint32_t inptrs = ip->i_sbd->sd_inptrs;
- unsigned int i = ip->i_di.di_height;
+ unsigned int i = ip->i_height;
memset(mp, 0, sizeof(struct metapath));
while (i--) {
@@ -462,7 +461,7 @@ void lookup_block(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
return;
*ptr = cpu_to_be64(*block);
bmodified(bh);
- ip->i_di.di_blocks++;
+ ip->i_blocks++;
bmodified(ip->i_bh);
*new = 1;
@@ -487,17 +486,17 @@ void block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
if (inode_is_stuffed(ip)) {
if (!lblock) {
- *dblock = ip->i_di.di_num.no_addr;
+ *dblock = ip->i_addr;
if (extlen)
*extlen = 1;
}
return;
}
- bsize = (S_ISDIR(ip->i_di.di_mode)) ? sdp->sd_jbsize : sdp->bsize;
+ bsize = (S_ISDIR(ip->i_mode)) ? sdp->sd_jbsize : sdp->bsize;
height = calc_tree_height(ip, (lblock + 1) * bsize);
- if (ip->i_di.di_height < height) {
+ if (ip->i_height < height) {
if (!create)
return;
@@ -505,7 +504,7 @@ void block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
}
find_metapath(ip, lblock, &mp);
- end_of_metadata = ip->i_di.di_height - 1;
+ end_of_metadata = ip->i_height - 1;
bh = ip->i_bh;
@@ -525,7 +524,7 @@ void block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
gfs2_meta_header_out(&mh, bh->b_data);
bmodified(bh);
} else {
- if (*dblock == ip->i_di.di_num.no_addr)
+ if (*dblock == ip->i_addr)
bh = ip->i_bh;
else
bh = bread(sdp, *dblock);
@@ -585,15 +584,15 @@ int gfs2_readi(struct gfs2_inode *ip, void *buf,
uint32_t extlen = 0;
unsigned int amount;
int not_new = 0;
- int isdir = !!(S_ISDIR(ip->i_di.di_mode));
- int journaled = ip->i_di.di_flags & GFS2_DIF_JDATA;
+ int isdir = !!(S_ISDIR(ip->i_mode));
+ int journaled = ip->i_flags & GFS2_DIF_JDATA;
int copied = 0;
- if (offset >= ip->i_di.di_size)
+ if (offset >= ip->i_size)
return 0;
- if ((offset + size) > ip->i_di.di_size)
- size = ip->i_di.di_size - offset;
+ if ((offset + size) > ip->i_size)
+ size = ip->i_size - offset;
if (!size)
return 0;
@@ -627,7 +626,7 @@ int gfs2_readi(struct gfs2_inode *ip, void *buf,
}
if (dblock) {
- if (dblock == ip->i_di.di_num.no_addr)
+ if (dblock == ip->i_addr)
bh = ip->i_bh;
else
bh = bread(sdp, dblock);
@@ -672,7 +671,7 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf,
uint32_t extlen = 0;
unsigned int amount;
int new;
- int isdir = !!(S_ISDIR(ip->i_di.di_mode));
+ int isdir = !!(S_ISDIR(ip->i_mode));
const uint64_t start = offset;
int copied = 0;
@@ -718,7 +717,7 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf,
bmodified(bh);
}
} else {
- if (dblock == ip->i_di.di_num.no_addr)
+ if (dblock == ip->i_addr)
bh = ip->i_bh;
else
bh = bread(sdp, dblock);
@@ -735,9 +734,9 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf,
o = (isdir) ? sizeof(struct gfs2_meta_header) : 0;
}
- if (resize && ip->i_di.di_size < start + copied) {
+ if (resize && ip->i_size < start + copied) {
bmodified(ip->i_bh);
- ip->i_di.di_size = start + copied;
+ ip->i_size = start + copied;
}
return copied;
@@ -804,7 +803,7 @@ static int dirent_alloc(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,
dent->de_name_len = cpu_to_be16(name_len);
bmodified(bh);
*dent_out = dent;
- dip->i_di.di_entries++;
+ dip->i_entries++;
bmodified(dip->i_bh);
return 0;
}
@@ -834,7 +833,7 @@ static int dirent_alloc(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,
*dent_out = new;
bmodified(bh);
- dip->i_di.di_entries++;
+ dip->i_entries++;
bmodified(dip->i_bh);
return 0;
}
@@ -843,7 +842,7 @@ static int dirent_alloc(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,
*dent_out = dent;
bmodified(bh);
- dip->i_di.di_entries++;
+ dip->i_entries++;
bmodified(dip->i_bh);
return 0;
}
@@ -866,9 +865,9 @@ void dirent2_del(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,
lf->lf_entries = cpu_to_be16(lf->lf_entries);
}
- if (dip->i_di.di_entries) {
+ if (dip->i_entries) {
bmodified(dip->i_bh);
- dip->i_di.di_entries--;
+ dip->i_entries--;
}
if (!prev) {
cur->de_inum.no_addr = 0;
@@ -925,7 +924,7 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
oleaf = (struct gfs2_leaf *)obh->b_data;
- len = 1 << (dip->i_di.di_depth - be16_to_cpu(oleaf->lf_depth));
+ len = 1 << (dip->i_depth - be16_to_cpu(oleaf->lf_depth));
half_len = len >> 1;
lp = calloc(1, half_len * sizeof(uint64_t));
@@ -949,7 +948,7 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
free(lp);
- divider = (start + half_len) << (32 - dip->i_di.di_depth);
+ divider = (start + half_len) << (32 - dip->i_depth);
gfs2_dirent_first(dip, obh, &dent);
@@ -994,15 +993,15 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
}
new->de_inum.no_formal_ino = 0;
/* Don't count the sentinel dirent as an entry */
- dip->i_di.di_entries--;
+ dip->i_entries--;
}
oleaf->lf_depth = be16_to_cpu(oleaf->lf_depth) + 1;
oleaf->lf_depth = cpu_to_be16(oleaf->lf_depth);
nleaf->lf_depth = oleaf->lf_depth;
- nleaf->lf_inode = cpu_to_be64(dip->i_di.di_num.no_addr);
- dip->i_di.di_blocks++;
+ nleaf->lf_inode = cpu_to_be64(dip->i_addr);
+ dip->i_blocks++;
bmodified(dip->i_bh);
bmodified(obh); /* Need to do this in case nothing was moved */
@@ -1025,7 +1024,7 @@ static void dir_double_exhash(struct gfs2_inode *dip)
exit(-1);
}
- for (block = dip->i_di.di_size >> sdp->sd_hash_bsize_shift; block--;) {
+ for (block = dip->i_size >> sdp->sd_hash_bsize_shift; block--;) {
count = gfs2_readi(dip, (char *)buf,
block * sdp->sd_hash_bsize,
sdp->sd_hash_bsize);
@@ -1058,7 +1057,7 @@ static void dir_double_exhash(struct gfs2_inode *dip)
free(buf);
- dip->i_di.di_depth++;
+ dip->i_depth++;
bmodified(dip->i_bh);
}
@@ -1151,8 +1150,8 @@ static int dir_e_add(struct gfs2_inode *dip, const char *filename, int len,
hash = gfs2_disk_hash(filename, len);
restart:
/* Have to kludge because (hash >> 32) gives hash for some reason. */
- if (dip->i_di.di_depth)
- lindex = hash >> (32 - dip->i_di.di_depth);
+ if (dip->i_depth)
+ lindex = hash >> (32 - dip->i_depth);
else
lindex = 0;
@@ -1166,15 +1165,15 @@ restart:
if (dirent_alloc(dip, bh, len, &dent)) {
- if (be16_to_cpu(leaf->lf_depth) < dip->i_di.di_depth) {
- llen = 1 << (dip->i_di.di_depth -
+ if (be16_to_cpu(leaf->lf_depth) < dip->i_depth) {
+ llen = 1 << (dip->i_depth -
be16_to_cpu(leaf->lf_depth));
dir_split_leaf(dip, lindex & ~(llen - 1),
leaf_no, bh);
brelse(bh);
goto restart;
- } else if (dip->i_di.di_depth < GFS2_DIR_MAX_DEPTH) {
+ } else if (dip->i_depth < GFS2_DIR_MAX_DEPTH) {
brelse(bh);
dir_double_exhash(dip);
goto restart;
@@ -1201,11 +1200,11 @@ restart:
nleaf = (struct gfs2_leaf *)nbh->b_data;
nleaf->lf_depth = leaf->lf_depth;
nleaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
- nleaf->lf_inode = cpu_to_be64(dip->i_di.di_num.no_addr);
+ nleaf->lf_inode = cpu_to_be64(dip->i_addr);
err = dirent_alloc(dip, nbh, len, &dent);
if (err)
return err;
- dip->i_di.di_blocks++;
+ dip->i_blocks++;
bmodified(dip->i_bh);
bmodified(bh);
brelse(bh);
@@ -1252,8 +1251,8 @@ static void dir_make_exhash(struct gfs2_inode *dip)
leaf = (struct gfs2_leaf *)bh->b_data;
leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
- leaf->lf_entries = cpu_to_be16(dip->i_di.di_entries);
- leaf->lf_inode = cpu_to_be64(dip->i_di.di_num.no_addr);
+ leaf->lf_entries = cpu_to_be16(dip->i_entries);
+ leaf->lf_inode = cpu_to_be64(dip->i_addr);
buffer_copy_tail(sdp, bh, sizeof(struct gfs2_leaf),
dip->i_bh, sizeof(struct gfs2_dinode));
@@ -1263,7 +1262,7 @@ static void dir_make_exhash(struct gfs2_inode *dip)
do {
if (!dent->de_inum.no_formal_ino)
continue;
- if (++x == dip->i_di.di_entries)
+ if (++x == dip->i_entries)
break;
} while (gfs2_dirent_next(dip, bh, &dent) == 0);
@@ -1281,16 +1280,16 @@ static void dir_make_exhash(struct gfs2_inode *dip)
for (x = sdp->sd_hash_ptrs; x--; lp++)
*lp = cpu_to_be64(bn);
- dip->i_di.di_size = sdp->bsize / 2;
- dip->i_di.di_blocks++;
- dip->i_di.di_flags |= GFS2_DIF_EXHASH;
- dip->i_di.di_payload_format = 0;
+ dip->i_size = sdp->bsize / 2;
+ dip->i_blocks++;
+ dip->i_flags |= GFS2_DIF_EXHASH;
+ dip->i_payload_format = 0;
/* no need: bmodified(dip->i_bh); buffer_clear_tail does it. */
for (x = sdp->sd_hash_ptrs, y = -1; x; x >>= 1, y++) ;
- dip->i_di.di_depth = y;
+ dip->i_depth = y;
- gfs2_dinode_out(&dip->i_di, dip->i_bh->b_data);
+ lgfs2_dinode_out(dip, dip->i_bh->b_data);
bwrite(dip->i_bh);
}
@@ -1319,7 +1318,7 @@ int dir_add(struct gfs2_inode *dip, const char *filename, int len,
struct gfs2_inum *inum, unsigned int type)
{
int err = 0;
- if (dip->i_di.di_flags & GFS2_DIF_EXHASH)
+ if (dip->i_flags & GFS2_DIF_EXHASH)
err = dir_e_add(dip, filename, len, inum, type);
else
err = dir_l_add(dip, filename, len, inum, type);
@@ -1433,15 +1432,15 @@ int lgfs2_write_filemeta(struct gfs2_inode *ip)
unsigned height = 0;
struct metapath mp;
struct gfs2_sbd *sdp = ip->i_sbd;
- uint64_t dblocks = (ip->i_di.di_size + sdp->bsize - 1) / sdp->bsize;
- uint64_t ptr0 = ip->i_di.di_num.no_addr + 1;
+ uint64_t dblocks = (ip->i_size + sdp->bsize - 1) / sdp->bsize;
+ uint64_t ptr0 = ip->i_addr + 1;
unsigned ptrs = 1;
struct gfs2_meta_header mh = {
.mh_magic = GFS2_MAGIC,
.mh_type = GFS2_METATYPE_IN,
.mh_format = GFS2_FORMAT_IN,
};
- struct gfs2_buffer_head *bh = bget(sdp, ip->i_di.di_num.no_addr);
+ struct gfs2_buffer_head *bh = bget(sdp, ip->i_addr);
if (bh == NULL)
return 1;
@@ -1450,7 +1449,7 @@ int lgfs2_write_filemeta(struct gfs2_inode *ip)
height. Just need to add 1 to convert ptr index to quantity later. */
find_metapath(ip, dblocks - 1, &mp);
- for (height = 0; height < ip->i_di.di_height; height++) {
+ for (height = 0; height < ip->i_height; height++) {
unsigned p;
/* The number of pointers in this height will be the number of
full indirect blocks pointed to by the previous height
@@ -1462,7 +1461,7 @@ int lgfs2_write_filemeta(struct gfs2_inode *ip)
char *start = bh->b_data;
if (height == 0) {
start += sizeof(struct gfs2_dinode);
- gfs2_dinode_out(&ip->i_di, bh->b_data);
+ lgfs2_dinode_out(ip, bh->b_data);
} else {
start += sizeof(struct gfs2_meta_header);
gfs2_meta_header_out(&mh, bh->b_data);
@@ -1493,6 +1492,10 @@ static struct gfs2_inode *__createi(struct gfs2_inode *dip,
gfs2_lookupi(dip, filename, strlen(filename), &ip);
if (!ip) {
+ struct gfs2_inum parent = {
+ .no_formal_ino = dip->i_formal_ino,
+ .no_addr = dip->i_addr,
+ };
err = lgfs2_dinode_alloc(sdp, 1, &bn);
if (err != 0)
return NULL;
@@ -1513,10 +1516,10 @@ static struct gfs2_inode *__createi(struct gfs2_inode *dip,
is_dir = S_ISDIR(mode);
if (is_dir) {
bmodified(dip->i_bh);
- dip->i_di.di_nlink++;
+ dip->i_nlink++;
}
- err = __init_dinode(sdp, &bh, &inum, mode, flags, &dip->i_di.di_num, if_gfs1);
+ err = __init_dinode(sdp, &bh, &inum, mode, flags, &parent, if_gfs1);
if (err != 0)
return NULL;
@@ -1586,7 +1589,7 @@ static int leaf_search(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,
struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
entries = be16_to_cpu(leaf->lf_entries);
} else if (type == IS_DINODE)
- entries = dip->i_di.di_entries;
+ entries = dip->i_entries;
else
return -1;
@@ -1636,14 +1639,14 @@ static int linked_leaf_search(struct gfs2_inode *dip, const char *filename,
uint32_t hash;
int error = 0;
- hsize = 1 << dip->i_di.di_depth;
- if(hsize * sizeof(uint64_t) != dip->i_di.di_size)
+ hsize = 1 << dip->i_depth;
+ if(hsize * sizeof(uint64_t) != dip->i_size)
return -1;
/* Figure out the address of the leaf node. */
hash = gfs2_disk_hash(filename, len);
- lindex = hash >> (32 - dip->i_di.di_depth);
+ lindex = hash >> (32 - dip->i_depth);
error = get_first_leaf(dip, lindex, &bh_next);
if (error)
@@ -1755,10 +1758,10 @@ int dir_search(struct gfs2_inode *dip, const char *filename, int len,
{
int error;
- if(!S_ISDIR(dip->i_di.di_mode) && !is_gfs_dir(&dip->i_di))
+ if(!S_ISDIR(dip->i_mode) && !is_gfs_dir(dip))
return -1;
- if (dip->i_di.di_flags & GFS2_DIF_EXHASH)
+ if (dip->i_flags & GFS2_DIF_EXHASH)
error = dir_e_search(dip, filename, len, type, inum);
else
error = dir_l_search(dip, filename, len, type, inum);
@@ -1775,7 +1778,7 @@ static int dir_e_del(struct gfs2_inode *dip, const char *filename, int len)
struct gfs2_buffer_head *bh = NULL;
struct gfs2_dirent *cur, *prev;
- lindex = (1 << (dip->i_di.di_depth))-1;
+ lindex = (1 << (dip->i_depth))-1;
for(; (lindex >= 0) && !found; lindex--){
error = lgfs2_get_leaf_ptr(dip, lindex, &leaf_no);
@@ -1843,10 +1846,10 @@ int gfs2_dirent_del(struct gfs2_inode *dip, const char *filename, int len)
{
int error;
- if(!S_ISDIR(dip->i_di.di_mode) && !is_gfs_dir(&dip->i_di))
+ if(!S_ISDIR(dip->i_mode) && !is_gfs_dir(dip))
return -1;
- if (dip->i_di.di_flags & GFS2_DIF_EXHASH)
+ if (dip->i_flags & GFS2_DIF_EXHASH)
error = dir_e_del(dip, filename, len);
else
error = dir_l_del(dip, filename, len);
@@ -1929,7 +1932,7 @@ int gfs2_freedi(struct gfs2_sbd *sdp, uint64_t diblock)
ip = lgfs2_inode_get(sdp, bh);
if (ip == NULL)
return -1;
- height = ip->i_di.di_height;
+ height = ip->i_height;
osi_list_add(&bh->b_altlist, &metalist[0]);
for (h = 0; h < height; h++){
diff --git a/gfs2/libgfs2/gfs1.c b/gfs2/libgfs2/gfs1.c
index b2294a8b..6f74ce4d 100644
--- a/gfs2/libgfs2/gfs1.c
+++ b/gfs2/libgfs2/gfs1.c
@@ -19,7 +19,7 @@
static __inline__ int fs_is_jdata(struct gfs2_inode *ip)
{
- return ip->i_di.di_flags & GFS2_DIF_JDATA;
+ return ip->i_flags & GFS2_DIF_JDATA;
}
static __inline__ uint64_t *
@@ -31,9 +31,9 @@ gfs1_metapointer(char *buf, unsigned int height, struct metapath *mp)
return ((uint64_t *)(buf + head_size)) + mp->mp_list[height];
}
-int is_gfs_dir(struct gfs2_dinode *dinode)
+int is_gfs_dir(struct gfs2_inode *ip)
{
- if (dinode->__pad1 == GFS_FILE_DIR)
+ if (ip->i_pad1 == GFS_FILE_DIR)
return 1;
return 0;
}
@@ -61,7 +61,7 @@ void gfs1_lookup_block(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
*ptr = cpu_to_be64(*block);
bmodified(bh);
- ip->i_di.di_blocks++;
+ ip->i_blocks++;
bmodified(ip->i_bh);
*new = 1;
@@ -84,9 +84,9 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
if (extlen)
*extlen = 0;
- if (!ip->i_di.di_height) { /* stuffed */
+ if (!ip->i_height) { /* stuffed */
if (!lblock) {
- *dblock = ip->i_di.di_num.no_addr;
+ *dblock = ip->i_addr;
if (extlen)
*extlen = 1;
}
@@ -96,7 +96,7 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
bsize = (fs_is_jdata(ip)) ? sdp->sd_jbsize : sdp->bsize;
height = calc_tree_height(ip, (lblock + 1) * bsize);
- if (ip->i_di.di_height < height) {
+ if (ip->i_height < height) {
if (!create)
return;
@@ -104,7 +104,7 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
}
find_metapath(ip, lblock, &mp);
- end_of_metadata = ip->i_di.di_height - 1;
+ end_of_metadata = ip->i_height - 1;
bh = ip->i_bh;
@@ -125,7 +125,7 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
gfs2_meta_header_out(&mh, bh->b_data);
bmodified(bh);
} else {
- if (*dblock == ip->i_di.di_num.no_addr)
+ if (*dblock == ip->i_addr)
bh = ip->i_bh;
else
bh = bread(sdp, *dblock);
@@ -179,7 +179,7 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
if (!size)
return 0;
- if (!ip->i_di.di_height && /* stuffed */
+ if (!ip->i_height && /* stuffed */
((start + size) > (sdp->bsize - sizeof(struct gfs_dinode))))
unstuff_dinode(ip);
@@ -191,7 +191,7 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
offset &= sdp->bsize - 1;
}
- if (!ip->i_di.di_height) /* stuffed */
+ if (!ip->i_height) /* stuffed */
offset += sizeof(struct gfs_dinode);
else if (journaled)
offset += sizeof(struct gfs2_meta_header);
@@ -208,12 +208,12 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
return -1;
}
- if (dblock == ip->i_di.di_num.no_addr)
+ if (dblock == ip->i_addr)
bh = ip->i_bh;
else
bh = bread(sdp, dblock);
- if (journaled && dblock != ip->i_di.di_num.no_addr ) {
+ if (journaled && dblock != ip->i_addr ) {
struct gfs2_meta_header mh;
mh.mh_magic = GFS2_MAGIC;
@@ -235,86 +235,58 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
offset = (journaled) ? sizeof(struct gfs2_meta_header) : 0;
}
- if (ip->i_di.di_size < start + copied) {
+ if (ip->i_size < start + copied) {
bmodified(ip->i_bh);
- ip->i_di.di_size = start + copied;
+ ip->i_size = start + copied;
}
- ip->i_di.di_mtime = ip->i_di.di_ctime = time(NULL);
- gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data);
+ ip->i_mtime = ip->i_ctime = time(NULL);
+ lgfs2_dinode_out(ip, ip->i_bh->b_data);
bmodified(ip->i_bh);
return copied;
}
-static void gfs_dinode_in(struct gfs_dinode *di, char *buf)
+static struct gfs2_inode *__gfs_inode_get(struct gfs2_sbd *sdp, char *buf)
{
- struct gfs_dinode *str = (struct gfs_dinode *)buf;
-
- gfs2_meta_header_in(&di->di_header, buf);
- gfs2_inum_in(&di->di_num, (char *)&str->di_num);
-
- di->di_mode = be32_to_cpu(str->di_mode);
- di->di_uid = be32_to_cpu(str->di_uid);
- di->di_gid = be32_to_cpu(str->di_gid);
- di->di_nlink = be32_to_cpu(str->di_nlink);
- di->di_size = be64_to_cpu(str->di_size);
- di->di_blocks = be64_to_cpu(str->di_blocks);
- di->di_atime = be64_to_cpu(str->di_atime);
- di->di_mtime = be64_to_cpu(str->di_mtime);
- di->di_ctime = be64_to_cpu(str->di_ctime);
- di->di_major = be32_to_cpu(str->di_major);
- di->di_minor = be32_to_cpu(str->di_minor);
- di->di_goal_dblk = be64_to_cpu(str->di_goal_dblk);
- di->di_goal_mblk = be64_to_cpu(str->di_goal_mblk);
- di->di_flags = be32_to_cpu(str->di_flags);
- di->di_payload_format = be32_to_cpu(str->di_payload_format);
- di->di_type = be16_to_cpu(str->di_type);
- di->di_height = be16_to_cpu(str->di_height);
- di->di_depth = be16_to_cpu(str->di_depth);
- di->di_entries = be32_to_cpu(str->di_entries);
- di->di_eattr = be64_to_cpu(str->di_eattr);
-}
-
-static struct gfs2_inode *__gfs_inode_get(struct gfs2_sbd *sdp, char *buf, uint64_t di_addr)
-{
- struct gfs_dinode gfs1_dinode;
+ struct gfs_dinode *di;
struct gfs2_inode *ip;
ip = calloc(1, sizeof(struct gfs2_inode));
if (ip == NULL) {
return NULL;
}
- gfs_dinode_in(&gfs1_dinode, buf);
- memcpy(&ip->i_di.di_header, &gfs1_dinode.di_header,
- sizeof(struct gfs2_meta_header));
- memcpy(&ip->i_di.di_num, &gfs1_dinode.di_num,
- sizeof(struct gfs2_inum));
- ip->i_di.di_mode = gfs1_dinode.di_mode;
- ip->i_di.di_uid = gfs1_dinode.di_uid;
- ip->i_di.di_gid = gfs1_dinode.di_gid;
- ip->i_di.di_nlink = gfs1_dinode.di_nlink;
- ip->i_di.di_size = gfs1_dinode.di_size;
- ip->i_di.di_blocks = gfs1_dinode.di_blocks;
- ip->i_di.di_atime = gfs1_dinode.di_atime;
- ip->i_di.di_mtime = gfs1_dinode.di_mtime;
- ip->i_di.di_ctime = gfs1_dinode.di_ctime;
- ip->i_di.di_major = gfs1_dinode.di_major;
- ip->i_di.di_minor = gfs1_dinode.di_minor;
- ip->i_di.di_goal_data = gfs1_dinode.di_goal_dblk;
- ip->i_di.di_goal_meta = gfs1_dinode.di_goal_mblk;
- ip->i_di.di_flags = gfs1_dinode.di_flags;
- ip->i_di.di_payload_format = gfs1_dinode.di_payload_format;
- ip->i_di.__pad1 = gfs1_dinode.di_type;
- ip->i_di.di_height = gfs1_dinode.di_height;
- ip->i_di.di_depth = gfs1_dinode.di_depth;
- ip->i_di.di_entries = gfs1_dinode.di_entries;
- ip->i_di.di_eattr = gfs1_dinode.di_eattr;
+ di = (struct gfs_dinode *)buf;
+ ip->i_magic = be32_to_cpu(di->di_header.mh_magic);
+ ip->i_type = be32_to_cpu(di->di_header.mh_type);
+ ip->i_format = be32_to_cpu(di->di_header.mh_format);
+ ip->i_formal_ino = be64_to_cpu(di->di_num.no_formal_ino);
+ ip->i_addr = be64_to_cpu(di->di_num.no_addr);
+ ip->i_mode = be32_to_cpu(di->di_mode);
+ ip->i_uid = be32_to_cpu(di->di_uid);
+ ip->i_gid = be32_to_cpu(di->di_gid);
+ ip->i_nlink = be32_to_cpu(di->di_nlink);
+ ip->i_size = be64_to_cpu(di->di_size);
+ ip->i_blocks = be64_to_cpu(di->di_blocks);
+ ip->i_atime = be64_to_cpu(di->di_atime);
+ ip->i_mtime = be64_to_cpu(di->di_mtime);
+ ip->i_ctime = be64_to_cpu(di->di_ctime);
+ ip->i_major = be32_to_cpu(di->di_major);
+ ip->i_minor = be32_to_cpu(di->di_minor);
+ ip->i_goal_data = (uint64_t)be32_to_cpu(di->di_goal_dblk);
+ ip->i_goal_meta = (uint64_t)be32_to_cpu(di->di_goal_mblk);
+ ip->i_flags = be32_to_cpu(di->di_flags);
+ ip->i_payload_format = be32_to_cpu(di->di_payload_format);
+ ip->i_pad1 = be16_to_cpu(di->di_type);
+ ip->i_height = be16_to_cpu(di->di_height);
+ ip->i_depth = be16_to_cpu(di->di_depth);
+ ip->i_entries = be32_to_cpu(di->di_entries);
+ ip->i_eattr = be64_to_cpu(di->di_eattr);
ip->i_sbd = sdp;
return ip;
}
struct gfs2_inode *lgfs2_gfs_inode_get(struct gfs2_sbd *sdp, char *buf)
{
- return __gfs_inode_get(sdp, buf, 0);
+ return __gfs_inode_get(sdp, buf);
}
struct gfs2_inode *lgfs2_gfs_inode_read(struct gfs2_sbd *sdp, uint64_t di_addr)
@@ -329,7 +301,7 @@ struct gfs2_inode *lgfs2_gfs_inode_read(struct gfs2_sbd *sdp, uint64_t di_addr)
brelse(bh);
return NULL;
}
- ip = __gfs_inode_get(sdp, bh->b_data, di_addr);
+ ip = __gfs_inode_get(sdp, bh->b_data);
ip->i_bh = bh;
ip->bh_owned = 1;
return ip;
diff --git a/gfs2/libgfs2/lang.c b/gfs2/libgfs2/lang.c
index 3faa5abd..da35b990 100644
--- a/gfs2/libgfs2/lang.c
+++ b/gfs2/libgfs2/lang.c
@@ -162,7 +162,7 @@ static uint64_t ast_lookup_path(char *path, struct gfs2_sbd *sbd)
while (ip != NULL) {
if (segment == NULL) { // No more segments
- bn = ip->i_di.di_num.no_addr;
+ bn = ip->i_addr;
inode_put(&ip);
return bn;
}
@@ -221,7 +221,7 @@ static uint64_t ast_lookup_id(const char *id, struct gfs2_sbd *sbd)
bn = sbd->sd_sb.sb_root_dir.no_addr;
break;
case ID_RINDEX:
- bn = sbd->md.riinode->i_di.di_num.no_addr;
+ bn = sbd->md.riinode->i_addr;
break;
default:
return 0;
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index feace819..cefb60c8 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -221,11 +221,45 @@ struct gfs2_buffer_head {
};
struct gfs2_inode {
- struct gfs2_dinode i_di;
struct gfs2_buffer_head *i_bh;
struct gfs2_sbd *i_sbd;
struct rgrp_tree *i_rgd; /* performance hint */
int bh_owned; /* Is this bh owned, iow, should we release it later? */
+
+ /* Native-endian versions of the dinode fields */
+ uint32_t i_magic;
+ uint32_t i_type;
+ uint32_t i_format;
+ uint64_t i_formal_ino;
+ uint64_t i_addr;
+ uint32_t i_mode;
+ uint32_t i_uid;
+ uint32_t i_gid;
+ uint32_t i_nlink;
+ uint64_t i_size;
+ uint64_t i_blocks;
+ uint64_t i_atime;
+ uint64_t i_mtime;
+ uint64_t i_ctime;
+ uint32_t i_major;
+ uint32_t i_minor;
+ uint64_t i_goal_meta;
+ uint64_t i_goal_data;
+ uint64_t i_generation;
+ uint32_t i_flags;
+ uint32_t i_payload_format;
+ uint16_t i_pad1;
+ uint16_t i_height;
+ uint32_t i_pad2;
+ uint16_t i_pad3;
+ uint16_t i_depth;
+ uint32_t i_entries;
+ uint64_t i_pad4_addr;
+ uint64_t i_pad4_formal_ino;
+ uint64_t i_eattr;
+ uint32_t i_atime_nsec;
+ uint32_t i_mtime_nsec;
+ uint32_t i_ctime_nsec;
};
struct master_dir
@@ -619,7 +653,7 @@ struct gfs_log_descriptor {
uint8_t ld_reserved[64];
};
-extern int is_gfs_dir(struct gfs2_dinode *dinode);
+extern int is_gfs_dir(struct gfs2_inode *ip);
extern void gfs1_lookup_block(struct gfs2_inode *ip,
struct gfs2_buffer_head *bh,
unsigned int height, struct metapath *mp,
@@ -717,8 +751,8 @@ 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 gfs2_dinode_in(struct gfs2_dinode *di, char *buf);
-extern void gfs2_dinode_out(struct gfs2_dinode *di, char *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);
extern void gfs2_dirent_out(struct gfs2_dirent *de, char *buf);
extern void gfs2_leaf_in(struct gfs2_leaf *lf, char *buf);
diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c
index b45fb13d..bcc91de4 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -284,74 +284,86 @@ void lgfs2_quota_print(void *qp)
printbe64(q, qu_value);
}
-void gfs2_dinode_in(struct gfs2_dinode *di, char *buf)
+void lgfs2_dinode_in(struct gfs2_inode *ip, char *buf)
{
- struct gfs2_dinode *str = (struct gfs2_dinode *)buf;
-
- gfs2_meta_header_in(&di->di_header, buf);
- gfs2_inum_in(&di->di_num, (char *)&str->di_num);
-
- CPIN_32(di, str, di_mode);
- CPIN_32(di, str, di_uid);
- CPIN_32(di, str, di_gid);
- CPIN_32(di, str, di_nlink);
- CPIN_64(di, str, di_size);
- CPIN_64(di, str, di_blocks);
- CPIN_64(di, str, di_atime);
- CPIN_64(di, str, di_mtime);
- CPIN_64(di, str, di_ctime);
- CPIN_32(di, str, di_major);
- CPIN_32(di, str, di_minor);
-
- CPIN_64(di, str, di_goal_meta);
- CPIN_64(di, str, di_goal_data);
-
- CPIN_32(di, str, di_flags);
- CPIN_32(di, str, di_payload_format);
- CPIN_16(di, str, __pad1);
- CPIN_16(di, str, di_height);
-
- CPIN_16(di, str, di_depth);
- CPIN_32(di, str, di_entries);
-
- CPIN_64(di, str, di_eattr);
-
- CPIN_08(di, str, di_reserved, 32);
+ struct gfs2_dinode *di = (struct gfs2_dinode *)buf;
+
+ ip->i_magic = be32_to_cpu(di->di_header.mh_magic);
+ ip->i_type = be32_to_cpu(di->di_header.mh_type);
+ ip->i_format = be32_to_cpu(di->di_header.mh_format);
+ ip->i_formal_ino = be64_to_cpu(di->di_num.no_formal_ino);
+ ip->i_addr = be64_to_cpu(di->di_num.no_addr);
+ ip->i_mode = be32_to_cpu(di->di_mode);
+ ip->i_uid = be32_to_cpu(di->di_uid);
+ ip->i_gid = be32_to_cpu(di->di_gid);
+ ip->i_nlink = be32_to_cpu(di->di_nlink);
+ ip->i_size = be64_to_cpu(di->di_size);
+ ip->i_blocks = be64_to_cpu(di->di_blocks);
+ ip->i_atime = be64_to_cpu(di->di_atime);
+ ip->i_mtime = be64_to_cpu(di->di_mtime);
+ ip->i_ctime = be64_to_cpu(di->di_ctime);
+ ip->i_major = be32_to_cpu(di->di_major);
+ ip->i_minor = be32_to_cpu(di->di_minor);
+ ip->i_goal_meta = be64_to_cpu(di->di_goal_meta);
+ ip->i_goal_data = be64_to_cpu(di->di_goal_data);
+ ip->i_generation = be64_to_cpu(di->di_generation);
+ ip->i_flags = be32_to_cpu(di->di_flags);
+ ip->i_payload_format = be32_to_cpu(di->di_payload_format);
+ ip->i_pad1 = be16_to_cpu(di->__pad1);
+ ip->i_height = be16_to_cpu(di->di_height);
+ ip->i_pad2 = be32_to_cpu(di->__pad2);
+ ip->i_pad3 = be16_to_cpu(di->__pad3);
+ ip->i_depth = be16_to_cpu(di->di_depth);
+ ip->i_entries = be32_to_cpu(di->di_entries);
+ ip->i_pad4_addr = be64_to_cpu(di->__pad4.no_addr);
+ ip->i_pad4_formal_ino = be64_to_cpu(di->__pad4.no_formal_ino);
+ ip->i_eattr = be64_to_cpu(di->di_eattr);
+ ip->i_atime_nsec = be32_to_cpu(di->di_atime_nsec);
+ ip->i_mtime_nsec = be32_to_cpu(di->di_mtime_nsec);
+ ip->i_ctime_nsec = be32_to_cpu(di->di_ctime_nsec);
}
-void gfs2_dinode_out(struct gfs2_dinode *di, char *buf)
+void lgfs2_dinode_out(struct gfs2_inode *ip, char *buf)
{
- struct gfs2_dinode *str = (struct gfs2_dinode *)buf;
-
- gfs2_meta_header_out(&di->di_header, buf);
- gfs2_inum_out(&di->di_num, (char *)&str->di_num);
-
- CPOUT_32(di, str, di_mode);
- CPOUT_32(di, str, di_uid);
- CPOUT_32(di, str, di_gid);
- CPOUT_32(di, str, di_nlink);
- CPOUT_64(di, str, di_size);
- CPOUT_64(di, str, di_blocks);
- CPOUT_64(di, str, di_atime);
- CPOUT_64(di, str, di_mtime);
- CPOUT_64(di, str, di_ctime);
- CPOUT_32(di, str, di_major);
- CPOUT_32(di, str, di_minor);
-
- CPOUT_64(di, str, di_goal_meta);
- CPOUT_64(di, str, di_goal_data);
-
- CPOUT_32(di, str, di_flags);
- CPOUT_32(di, str, di_payload_format);
- CPOUT_16(di, str, __pad1);
- CPOUT_16(di, str, di_height);
-
- CPOUT_16(di, str, di_depth);
- CPOUT_32(di, str, di_entries);
-
- CPOUT_64(di, str, di_eattr);
-
- CPOUT_08(di, str, di_reserved, 32);
+ struct gfs2_dinode *di = (struct gfs2_dinode *)buf;
+
+ di->di_header.mh_magic = cpu_to_be32(ip->i_magic);
+ di->di_header.mh_type = cpu_to_be32(ip->i_type);
+ di->di_header.mh_format = cpu_to_be32(ip->i_format);
+ di->di_num.no_formal_ino = cpu_to_be64(ip->i_formal_ino);
+ di->di_num.no_addr = cpu_to_be64(ip->i_addr);
+ di->di_mode = cpu_to_be32(ip->i_mode);
+ di->di_uid = cpu_to_be32(ip->i_uid);
+ di->di_gid = cpu_to_be32(ip->i_gid);
+ di->di_nlink = cpu_to_be32(ip->i_nlink);
+ di->di_size = cpu_to_be64(ip->i_size);
+ di->di_blocks = cpu_to_be64(ip->i_blocks);
+ di->di_atime = cpu_to_be64(ip->i_atime);
+ di->di_mtime = cpu_to_be64(ip->i_mtime);
+ di->di_ctime = cpu_to_be64(ip->i_ctime);
+ di->di_major = cpu_to_be32(ip->i_major);
+ di->di_minor = cpu_to_be32(ip->i_minor);
+
+ di->di_goal_meta = cpu_to_be64(ip->i_goal_meta);
+ di->di_goal_data = cpu_to_be64(ip->i_goal_data);
+ di->di_generation = cpu_to_be64(ip->i_generation);
+
+ di->di_flags = cpu_to_be32(ip->i_flags);
+ di->di_payload_format = cpu_to_be32(ip->i_payload_format);
+ di->__pad1 = cpu_to_be16(ip->i_pad1);
+ di->di_height = cpu_to_be16(ip->i_height);
+ di->__pad2 = cpu_to_be32(ip->i_pad2);
+ di->__pad3 = cpu_to_be16(ip->i_pad3);
+ di->di_depth = cpu_to_be16(ip->i_depth);
+ di->di_entries = cpu_to_be32(ip->i_entries);
+
+ di->__pad4.no_addr = cpu_to_be64(ip->i_pad4_addr);
+ di->__pad4.no_formal_ino = cpu_to_be64(ip->i_pad4_formal_ino);
+
+ di->di_eattr = cpu_to_be64(ip->i_eattr);
+ di->di_atime_nsec = cpu_to_be32(ip->i_atime_nsec);
+ di->di_mtime_nsec = cpu_to_be32(ip->i_mtime_nsec);
+ di->di_ctime_nsec = cpu_to_be32(ip->i_ctime_nsec);
}
void lgfs2_dinode_print(void *dip)
diff --git a/gfs2/libgfs2/recovery.c b/gfs2/libgfs2/recovery.c
index 429b222b..7c445f15 100644
--- a/gfs2/libgfs2/recovery.c
+++ b/gfs2/libgfs2/recovery.c
@@ -16,7 +16,7 @@
void gfs2_replay_incr_blk(struct gfs2_inode *ip, unsigned int *blk)
{
- uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
if (++*blk == jd_blocks)
*blk = 0;
@@ -116,7 +116,7 @@ static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk, struct lgfs2_l
{
unsigned int orig_blk = *blk;
int error;
- uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
for (;;) {
error = lgfs2_get_log_header(ip, *blk, head);
@@ -145,7 +145,7 @@ static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk, struct lgfs2_l
static int jhead_scan(struct gfs2_inode *ip, struct lgfs2_log_header *head)
{
unsigned int blk = head->lh_blkno;
- uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
struct lgfs2_log_header lh;
int error;
@@ -185,7 +185,7 @@ int lgfs2_find_jhead(struct gfs2_inode *ip, struct lgfs2_log_header *head)
{
struct lgfs2_log_header lh_1, lh_m;
uint32_t blk_1, blk_2, blk_m;
- uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
int error;
blk_1 = 0;
diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c
index d70aeaef..562640f7 100644
--- a/gfs2/libgfs2/structures.c
+++ b/gfs2/libgfs2/structures.c
@@ -125,8 +125,8 @@ uint32_t lgfs2_log_header_crc(char *buf, unsigned bsize)
int lgfs2_write_journal_data(struct gfs2_inode *ip)
{
struct gfs2_sbd *sdp = ip->i_sbd;
- unsigned blocks = (ip->i_di.di_size + sdp->bsize - 1) / sdp->bsize;
- uint64_t jext0 = ip->i_di.di_num.no_addr + ip->i_di.di_blocks - blocks;
+ unsigned blocks = (ip->i_size + sdp->bsize - 1) / sdp->bsize;
+ uint64_t jext0 = ip->i_addr + ip->i_blocks - blocks;
uint64_t seq = ((blocks) * (random() / (RAND_MAX + 1.0)));
struct gfs2_log_header *lh;
uint64_t jblk = jext0;
@@ -141,7 +141,7 @@ int lgfs2_write_journal_data(struct gfs2_inode *ip)
lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_USERSPACE);
- lh->lh_jinode = cpu_to_be64(ip->i_di.di_num.no_addr);
+ lh->lh_jinode = cpu_to_be64(ip->i_addr);
crc32c_optimization_init();
do {
@@ -178,7 +178,7 @@ static struct gfs2_buffer_head *get_file_buf(struct gfs2_inode *ip, uint64_t lbn
uint64_t dbn;
int new = 1;
- if (ip->i_di.di_height == 0)
+ if (ip->i_height == 0)
unstuff_dinode(ip);
block_map(ip, lbn, &new, &dbn, NULL, prealloc);
@@ -186,11 +186,11 @@ static struct gfs2_buffer_head *get_file_buf(struct gfs2_inode *ip, uint64_t lbn
return NULL;
if (!prealloc && new &&
- ip->i_di.di_size < (lbn + 1) << sdp->sd_sb.sb_bsize_shift) {
+ ip->i_size < (lbn + 1) << sdp->sd_sb.sb_bsize_shift) {
bmodified(ip->i_bh);
- ip->i_di.di_size = (lbn + 1) << sdp->sd_sb.sb_bsize_shift;
+ ip->i_size = (lbn + 1) << sdp->sd_sb.sb_bsize_shift;
}
- if (dbn == ip->i_di.di_num.no_addr)
+ if (dbn == ip->i_addr)
return ip->i_bh;
else
return bread(sdp, dbn);
@@ -228,7 +228,7 @@ int write_journal(struct gfs2_inode *jnl, unsigned bsize, unsigned int blocks)
lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_USERSPACE);
- lh->lh_jinode = cpu_to_be64(jnl->i_di.di_num.no_addr);
+ lh->lh_jinode = cpu_to_be64(jnl->i_addr);
lh->lh_sequence = cpu_to_be64(seq);
lh->lh_blkno = cpu_to_be32(x);
@@ -346,8 +346,8 @@ int build_inum_range(struct gfs2_inode *per_node, unsigned int j)
if (ip == NULL) {
return errno;
}
- ip->i_di.di_size = sizeof(struct gfs2_inum_range);
- gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data);
+ ip->i_size = sizeof(struct gfs2_inum_range);
+ lgfs2_dinode_out(ip, ip->i_bh->b_data);
bmodified(ip->i_bh);
if (cfg_debug) {
printf("\nInum Range %u:\n", j);
@@ -369,8 +369,8 @@ int build_statfs_change(struct gfs2_inode *per_node, unsigned int j)
if (ip == NULL) {
return errno;
}
- ip->i_di.di_size = sizeof(struct gfs2_statfs_change);
- gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data);
+ ip->i_size = sizeof(struct gfs2_statfs_change);
+ lgfs2_dinode_out(ip, ip->i_bh->b_data);
bmodified(ip->i_bh);
if (cfg_debug) {
printf("\nStatFS Change %u:\n", j);
@@ -513,7 +513,7 @@ int build_rindex(struct gfs2_sbd *sdp)
if (ip == NULL) {
return errno;
}
- ip->i_di.di_payload_format = GFS2_FORMAT_RI;
+ ip->i_payload_format = GFS2_FORMAT_RI;
bmodified(ip->i_bh);
for (n = osi_first(&sdp->rgtree); n; n = next) {
@@ -522,14 +522,12 @@ int build_rindex(struct gfs2_sbd *sdp)
gfs2_rindex_out(&rl->ri, buf);
- count = gfs2_writei(ip, buf, ip->i_di.di_size,
- sizeof(struct gfs2_rindex));
+ count = gfs2_writei(ip, buf, ip->i_size, sizeof(struct gfs2_rindex));
if (count != sizeof(struct gfs2_rindex))
return -1;
}
memset(buf, 0, sizeof(struct gfs2_rindex));
- count = __gfs2_writei(ip, buf, ip->i_di.di_size,
- sizeof(struct gfs2_rindex), 0);
+ count = __gfs2_writei(ip, buf, ip->i_size, sizeof(struct gfs2_rindex), 0);
if (count != sizeof(struct gfs2_rindex))
return -1;
@@ -553,16 +551,16 @@ int build_quota(struct gfs2_sbd *sdp)
if (ip == NULL) {
return errno;
}
- ip->i_di.di_payload_format = GFS2_FORMAT_QU;
+ ip->i_payload_format = GFS2_FORMAT_QU;
bmodified(ip->i_bh);
memset(&qu, 0, sizeof(struct gfs2_quota));
qu.qu_value = cpu_to_be64(1);
- count = gfs2_writei(ip, &qu, ip->i_di.di_size, sizeof(struct gfs2_quota));
+ count = gfs2_writei(ip, &qu, ip->i_size, sizeof(struct gfs2_quota));
if (count != sizeof(struct gfs2_quota))
return -1;
- count = gfs2_writei(ip, &qu, ip->i_di.di_size, sizeof(struct gfs2_quota));
+ count = gfs2_writei(ip, &qu, ip->i_size, sizeof(struct gfs2_quota));
if (count != sizeof(struct gfs2_quota))
return -1;
diff --git a/gfs2/libgfs2/super.c b/gfs2/libgfs2/super.c
index bf65b127..e8ade2e2 100644
--- a/gfs2/libgfs2/super.c
+++ b/gfs2/libgfs2/super.c
@@ -207,7 +207,7 @@ int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount, int *ok)
*ok = 1;
*rgcount = 0;
- if (sdp->md.riinode->i_di.di_size % sizeof(struct gfs2_rindex))
+ 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,
diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c
index 19b248d2..32211db7 100644
--- a/gfs2/mkfs/main_mkfs.c
+++ b/gfs2/mkfs/main_mkfs.c
@@ -867,7 +867,7 @@ 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_di.di_num.no_addr = lgfs2_rgrp_index(rg)->ri_data0;
+ in.i_addr = lgfs2_rgrp_index(rg)->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 */
@@ -894,7 +894,8 @@ static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, struct mkfs_o
fprintf(stderr, _("Failed to write data blocks for journal %u\n"), j);
return result;
}
- mkfs_journals[j] = in.i_di.di_num;
+ mkfs_journals[j].no_addr = in.i_addr;
+ mkfs_journals[j].no_formal_ino = in.i_formal_ino;
}
gfs2_progress_close(&progress, _("Done\n"));
@@ -1197,7 +1198,8 @@ int main(int argc, char *argv[])
fprintf(stderr, _("Error building '%s': %s\n"), "master", strerror(errno));
exit(EXIT_FAILURE);
}
- sb.sb_master_dir = sbd.master_dir->i_di.di_num;
+ sb.sb_master_dir.no_addr = sbd.master_dir->i_addr;
+ sb.sb_master_dir.no_formal_ino = sbd.master_dir->i_formal_ino;
error = lgfs2_build_jindex(sbd.master_dir, mkfs_journals, opts.journals);
if (error) {
@@ -1240,7 +1242,8 @@ int main(int argc, char *argv[])
printf("%s", _("Done\n"));
build_root(&sbd);
- sb.sb_root_dir = sbd.md.rooti->i_di.di_num;
+ sb.sb_root_dir.no_addr = sbd.md.rooti->i_addr;
+ sb.sb_root_dir.no_formal_ino = sbd.md.rooti->i_formal_ino;
strncpy(sb.sb_lockproto, opts.lockproto, GFS2_LOCKNAME_LEN - 1);
strncpy(sb.sb_locktable, opts.locktable, GFS2_LOCKNAME_LEN - 1);
diff --git a/tests/nukerg.c b/tests/nukerg.c
index f2018fbf..f323d643 100644
--- a/tests/nukerg.c
+++ b/tests/nukerg.c
@@ -260,7 +260,7 @@ static lgfs2_rgrps_t read_rindex(struct gfs2_sbd *sdp)
strerror(errno));
return NULL;
}
- rgcount = sdp->md.riinode->i_di.di_size / sizeof(struct gfs2_rindex);
+ rgcount = sdp->md.riinode->i_size / sizeof(struct gfs2_rindex);
for (i = 0; i < rgcount; i++) {
const struct gfs2_rindex *ri;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
- 1
- 0
[gfs2-utils] 18/40: libgfs2: Remove gfs2_dinode_print()
by pagure＠pagure.io
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 d26557526e4c829144b64781ebc0a25b36186fcc
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Mon May 10 14:28:15 2021 +0100
libgfs2: Remove gfs2_dinode_print()
Convert users to lgfs2_dinode_print() except the one in mkfs.gfs2 as we
don't have a big-endian dinode easily available. That one will be added
back once ip.i_di endianness mismatches have been resolved.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/libgfs2/libgfs2.h | 1 -
gfs2/libgfs2/ondisk.c | 30 ------------------------------
gfs2/libgfs2/structures.c | 22 +++++++++++-----------
gfs2/mkfs/main_mkfs.c | 3 ---
4 files changed, 11 insertions(+), 45 deletions(-)
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index 2c4b856e..feace819 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -729,7 +729,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);
-extern void gfs2_dinode_print(const struct gfs2_dinode *di);
/* 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);
diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c
index d46dd863..b45fb13d 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -354,36 +354,6 @@ void gfs2_dinode_out(struct gfs2_dinode *di, char *buf)
CPOUT_08(di, str, di_reserved, 32);
}
-void gfs2_dinode_print(const struct gfs2_dinode *di)
-{
- gfs2_meta_header_print(&di->di_header);
- gfs2_inum_print(&di->di_num);
-
- pv(di, di_mode, "0%"PRIo32, NULL);
- pv(di, di_uid, "%"PRIu32, "0x%"PRIx32);
- pv(di, di_gid, "%"PRIu32, "0x%"PRIx32);
- pv(di, di_nlink, "%"PRIu32, "0x%"PRIx32);
- pv(di, di_size, "%"PRIu64, "0x%"PRIx64);
- pv(di, di_blocks, "%"PRIu64, "0x%"PRIx64);
- pv(di, di_atime, "%"PRIu64, "0x%"PRIx64);
- pv(di, di_mtime, "%"PRIu64, "0x%"PRIx64);
- pv(di, di_ctime, "%"PRIu64, "0x%"PRIx64);
- pv(di, di_major, "%"PRIu32, "0x%"PRIx32);
- pv(di, di_minor, "%"PRIu32, "0x%"PRIx32);
-
- pv(di, di_goal_meta, "%"PRIu64, "0x%"PRIx64);
- pv(di, di_goal_data, "%"PRIu64, "0x%"PRIx64);
-
- pv(di, di_flags, "0x%.8"PRIX32, NULL);
- pv(di, di_payload_format, "%"PRIu32, "0x%"PRIx32);
- pv(di, di_height, "%"PRIu16, "0x%"PRIx16);
-
- pv(di, di_depth, "%"PRIu16, "0x%"PRIx16);
- pv(di, di_entries, "%"PRIu32, "0x%"PRIx32);
-
- pv(di, di_eattr, "%"PRIu64, "0x%"PRIx64);
-}
-
void lgfs2_dinode_print(void *dip)
{
struct gfs2_dinode *di = dip;
diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c
index 4ef4e685..d70aeaef 100644
--- a/gfs2/libgfs2/structures.c
+++ b/gfs2/libgfs2/structures.c
@@ -40,7 +40,7 @@ int build_master(struct gfs2_sbd *sdp)
if (cfg_debug) {
printf("\nMaster dir:\n");
- gfs2_dinode_print(&sdp->master_dir->i_di);
+ lgfs2_dinode_print(bh->b_data);
}
sdp->master_dir->bh_owned = 1;
return 0;
@@ -299,7 +299,7 @@ int lgfs2_build_jindex(struct gfs2_inode *master, struct gfs2_inum *jnls, size_t
if (cfg_debug) {
printf("\nJindex:\n");
- gfs2_dinode_print(&jindex->i_di);
+ lgfs2_dinode_print(jindex->i_bh->b_data);
}
inode_put(&jindex);
@@ -327,7 +327,7 @@ int build_jindex(struct gfs2_sbd *sdp)
}
if (cfg_debug) {
printf("\nJindex:\n");
- gfs2_dinode_print(&jindex->i_di);
+ lgfs2_dinode_print(jindex->i_bh->b_data);
}
free(sdp->md.journal);
@@ -351,7 +351,7 @@ int build_inum_range(struct gfs2_inode *per_node, unsigned int j)
bmodified(ip->i_bh);
if (cfg_debug) {
printf("\nInum Range %u:\n", j);
- gfs2_dinode_print(&ip->i_di);
+ lgfs2_dinode_print(ip->i_bh->b_data);
}
inode_put(&ip);
@@ -374,7 +374,7 @@ int build_statfs_change(struct gfs2_inode *per_node, unsigned int j)
bmodified(ip->i_bh);
if (cfg_debug) {
printf("\nStatFS Change %u:\n", j);
- gfs2_dinode_print(&ip->i_di);
+ lgfs2_dinode_print(ip->i_bh->b_data);
}
inode_put(&ip);
@@ -419,7 +419,7 @@ int build_quota_change(struct gfs2_inode *per_node, unsigned int j)
if (cfg_debug) {
printf("\nQuota Change %u:\n", j);
- gfs2_dinode_print(&ip->i_di);
+ lgfs2_dinode_print(ip->i_bh->b_data);
}
inode_put(&ip);
@@ -455,7 +455,7 @@ int build_per_node(struct gfs2_sbd *sdp)
if (cfg_debug) {
printf("\nper_node:\n");
- gfs2_dinode_print(&per_node->i_di);
+ lgfs2_dinode_print(per_node->i_bh->b_data);
}
inode_put(&per_node);
@@ -474,7 +474,7 @@ int build_inum(struct gfs2_sbd *sdp)
if (cfg_debug) {
printf("\nInum Inode:\n");
- gfs2_dinode_print(&ip->i_di);
+ lgfs2_dinode_print(ip->i_bh->b_data);
}
inode_put(&ip);
@@ -493,7 +493,7 @@ int build_statfs(struct gfs2_sbd *sdp)
if (cfg_debug) {
printf("\nStatFS Inode:\n");
- gfs2_dinode_print(&ip->i_di);
+ lgfs2_dinode_print(ip->i_bh->b_data);
}
inode_put(&ip);
@@ -535,7 +535,7 @@ int build_rindex(struct gfs2_sbd *sdp)
if (cfg_debug) {
printf("\nResource Index:\n");
- gfs2_dinode_print(&ip->i_di);
+ lgfs2_dinode_print(ip->i_bh->b_data);
}
inode_put(&ip);
@@ -598,7 +598,7 @@ int build_root(struct gfs2_sbd *sdp)
if (cfg_debug) {
printf("\nRoot directory:\n");
- gfs2_dinode_print(&sdp->md.rooti->i_di);
+ lgfs2_dinode_print(bh->b_data);
}
sdp->md.rooti->bh_owned = 1;
return 0;
diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c
index 2400cc8e..19b248d2 100644
--- a/gfs2/mkfs/main_mkfs.c
+++ b/gfs2/mkfs/main_mkfs.c
@@ -877,9 +877,6 @@ static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, struct mkfs_o
return result;
}
- if (opts->debug)
- gfs2_dinode_print(&in.i_di);
-
result = place_rgrp(sdp, rg, opts->debug);
if (result != 0)
return result;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
- 1
- 0
[gfs2-utils] 17/40: libgfs2: Add a cpu-endian log header struct
by pagure＠pagure.io
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 75046254d13b430de1e4a0382203df70556bd1fe
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Mon May 10 10:32:44 2021 +0100
libgfs2: Add a cpu-endian log header struct
This allows gfs2_log_header_{in,out} to be removed and replaced with a
smaller, static log_header_in() function.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/edit/extended.c | 4 ++--
gfs2/fsck/fs_recovery.c | 21 ++++++++++-----------
gfs2/libgfs2/libgfs2.h | 22 ++++++++++++++++------
gfs2/libgfs2/ondisk.c | 44 --------------------------------------------
gfs2/libgfs2/recovery.c | 40 ++++++++++++++++++++++++++++------------
5 files changed, 56 insertions(+), 75 deletions(-)
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index 4e8a003d..c977b6e1 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -473,7 +473,7 @@ static int print_gfs_jindex(struct gfs2_inode *dij)
static int print_gfs2_jindex(void)
{
int d, error;
- struct gfs2_log_header head;
+ struct lgfs2_log_header head;
struct gfs2_inode *ip;
for (d = 0; d < indirect->ii[0].dirents; d++) {
@@ -484,7 +484,7 @@ static int print_gfs2_jindex(void)
indirect->ii[0].dirent[d].filename,
indirect->ii[0].dirent[d].block,
ip->i_di.di_size / 1048576);
- error = gfs2_find_jhead(ip, &head);
+ error = lgfs2_find_jhead(ip, &head);
if (error) {
print_gfs2("corrupt.");
} else {
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index c7704b0e..6251ba90 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -337,9 +337,9 @@ static int foreach_descriptor(struct gfs2_inode *ip, unsigned int start,
length = be32_to_cpu(ld->ld_length);
if (be32_to_cpu(ld->ld_header.mh_type) == GFS2_METATYPE_LH) {
- struct gfs2_log_header lh;
+ struct lgfs2_log_header lh;
- error = get_log_header(ip, start, &lh);
+ error = lgfs2_get_log_header(ip, start, &lh);
if (!error) {
gfs2_replay_incr_blk(ip, &start);
bmodified(bh);
@@ -401,7 +401,7 @@ static int check_journal_seq_no(struct gfs2_inode *ip, int fix)
int error = 0, wrapped = 0;
uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
uint32_t blk;
- struct gfs2_log_header lh;
+ struct lgfs2_log_header lh;
uint64_t highest_seq = 0, lowest_seq = 0, prev_seq = 0;
int new = 0;
uint64_t dblock;
@@ -410,7 +410,7 @@ static int check_journal_seq_no(struct gfs2_inode *ip, int fix)
memset(&lh, 0, sizeof(lh));
for (blk = 0; blk < jd_blocks; blk++) {
- error = get_log_header(ip, blk, &lh);
+ error = lgfs2_get_log_header(ip, blk, &lh);
if (error == 1) /* if not a log header */
continue; /* just journal data--ignore it */
if (!lowest_seq || lh.lh_sequence < lowest_seq)
@@ -436,12 +436,11 @@ static int check_journal_seq_no(struct gfs2_inode *ip, int fix)
if (!fix)
continue;
highest_seq++;
- lh.lh_sequence = highest_seq;
prev_seq = lh.lh_sequence;
- log_warn(_("Renumbering it as 0x%"PRIx64"\n"), lh.lh_sequence);
+ log_warn(_("Renumbering it as 0x%"PRIx64"\n"), highest_seq);
block_map(ip, blk, &new, &dblock, NULL, 0);
bh = bread(ip->i_sbd, dblock);
- gfs2_log_header_out(&lh, bh->b_data);
+ ((struct gfs2_log_header *)bh->b_data)->lh_sequence = cpu_to_be64(highest_seq);
bmodified(bh);
brelse(bh);
}
@@ -492,7 +491,7 @@ static int gfs2_recover_journal(struct gfs2_inode *ip, int j, int preen,
int force_check, int *was_clean)
{
struct gfs2_sbd *sdp = ip->i_sbd;
- struct gfs2_log_header head;
+ struct lgfs2_log_header head;
unsigned int pass;
int error;
@@ -500,7 +499,7 @@ static int gfs2_recover_journal(struct gfs2_inode *ip, int j, int preen,
log_info( _("jid=%u: Looking at journal...\n"), j);
osi_list_init(&sd_revoke_list);
- error = gfs2_find_jhead(ip, &head);
+ error = lgfs2_find_jhead(ip, &head);
if (!error) {
error = check_journal_seq_no(ip, 0);
if (error > JOURNAL_SEQ_TOLERANCE) {
@@ -541,7 +540,7 @@ static int gfs2_recover_journal(struct gfs2_inode *ip, int j, int preen,
j);
goto out;
}
- error = gfs2_find_jhead(ip, &head);
+ error = lgfs2_find_jhead(ip, &head);
if (error) {
log_err( _("jid=%u: Unable to fix the bad journal.\n"),
j);
@@ -591,7 +590,7 @@ static int gfs2_recover_journal(struct gfs2_inode *ip, int j, int preen,
}
log_info( _("jid=%u: Found %u revoke tags\n"), j, sd_found_revokes);
gfs2_revoke_clean(sdp);
- error = clean_journal(ip, &head);
+ error = lgfs2_clean_journal(ip, &head);
if (error)
goto out;
log_err( _("jid=%u: Replayed %u of %u journaled data blocks\n"),
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index 922d35f8..2c4b856e 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -299,6 +299,18 @@ struct gfs2_sbd {
int gfs1;
};
+struct lgfs2_log_header {
+ uint64_t lh_sequence;
+ uint32_t lh_flags;
+ uint32_t lh_tail;
+ uint32_t lh_blkno;
+ uint32_t lh_hash;
+ uint32_t lh_crc;
+ int64_t lh_local_total;
+ int64_t lh_local_free;
+ int64_t lh_local_dinodes;
+};
+
struct metapath {
unsigned int mp_list[GFS2_MAX_META_HEIGHT];
};
@@ -638,10 +650,10 @@ extern int gfs2_revoke_add(struct gfs2_sbd *sdp, uint64_t blkno, unsigned int wh
extern int gfs2_revoke_check(struct gfs2_sbd *sdp, uint64_t blkno,
unsigned int where);
extern void gfs2_revoke_clean(struct gfs2_sbd *sdp);
-extern int get_log_header(struct gfs2_inode *ip, unsigned int blk,
- struct gfs2_log_header *head);
-extern int gfs2_find_jhead(struct gfs2_inode *ip, struct gfs2_log_header *head);
-extern int clean_journal(struct gfs2_inode *ip, struct gfs2_log_header *head);
+extern int lgfs2_get_log_header(struct gfs2_inode *ip, unsigned int blk,
+ struct lgfs2_log_header *head);
+extern int lgfs2_find_jhead(struct gfs2_inode *ip, struct lgfs2_log_header *head);
+extern int lgfs2_clean_journal(struct gfs2_inode *ip, struct lgfs2_log_header *head);
/* rgrp.c */
extern int gfs2_compute_bitstructs(const uint32_t bsize, struct rgrp_tree *rgd);
@@ -711,8 +723,6 @@ extern void gfs2_dirent_in(struct gfs2_dirent *de, char *buf);
extern void gfs2_dirent_out(struct gfs2_dirent *de, char *buf);
extern void gfs2_leaf_in(struct gfs2_leaf *lf, char *buf);
extern void gfs2_leaf_out(struct gfs2_leaf *lf, char *buf);
-extern void gfs2_log_header_in(struct gfs2_log_header *lh, char *buf);
-extern void gfs2_log_header_out(struct gfs2_log_header *lh, char *buf);
/* Printing functions */
diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c
index b9b8a67e..d46dd863 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -507,50 +507,6 @@ void lgfs2_ea_header_print(void *eap)
print_it(" name", "%s", NULL, buf);
}
-void gfs2_log_header_in(struct gfs2_log_header *lh, char *buf)
-{
- struct gfs2_log_header *str = (struct gfs2_log_header *)buf;
-
- gfs2_meta_header_in(&lh->lh_header, buf);
- CPIN_64(lh, str, lh_sequence);
- CPIN_32(lh, str, lh_flags);
- CPIN_32(lh, str, lh_tail);
- CPIN_32(lh, str, lh_blkno);
- CPIN_32(lh, str, lh_hash);
- CPIN_32(lh, str, lh_crc);
- CPIN_32(lh, str, lh_nsec);
- CPIN_64(lh, str, lh_sec);
- CPIN_64(lh, str, lh_addr);
- CPIN_64(lh, str, lh_jinode);
- CPIN_64(lh, str, lh_statfs_addr);
- CPIN_64(lh, str, lh_quota_addr);
- CPIN_64(lh, str, lh_local_total);
- CPIN_64(lh, str, lh_local_free);
- CPIN_64(lh, str, lh_local_dinodes);
-}
-
-void gfs2_log_header_out(struct gfs2_log_header *lh, char *buf)
-{
- struct gfs2_log_header *str = (struct gfs2_log_header *)buf;
-
- gfs2_meta_header_out(&lh->lh_header, buf);
- CPOUT_64(lh, str, lh_sequence);
- CPOUT_32(lh, str, lh_flags);
- CPOUT_32(lh, str, lh_tail);
- CPOUT_32(lh, str, lh_blkno);
- CPOUT_32(lh, str, lh_hash);
- CPOUT_32(lh, str, lh_crc);
- CPOUT_32(lh, str, lh_nsec);
- CPOUT_64(lh, str, lh_sec);
- CPOUT_64(lh, str, lh_addr);
- CPOUT_64(lh, str, lh_jinode);
- CPOUT_64(lh, str, lh_statfs_addr);
- CPOUT_64(lh, str, lh_quota_addr);
- CPOUT_64(lh, str, lh_local_total);
- CPOUT_64(lh, str, lh_local_free);
- CPOUT_64(lh, str, lh_local_dinodes);
-}
-
void lgfs2_log_header_print(void *lhp)
{
struct gfs2_log_header *lh = lhp;
diff --git a/gfs2/libgfs2/recovery.c b/gfs2/libgfs2/recovery.c
index 78136ac2..429b222b 100644
--- a/gfs2/libgfs2/recovery.c
+++ b/gfs2/libgfs2/recovery.c
@@ -36,6 +36,21 @@ int gfs2_replay_read_block(struct gfs2_inode *ip, unsigned int blk,
return 0;
}
+static void log_header_in(struct lgfs2_log_header *lh, char *buf)
+{
+ struct gfs2_log_header *lhd = (struct gfs2_log_header *)buf;
+
+ lh->lh_sequence = be64_to_cpu(lhd->lh_sequence);
+ lh->lh_flags = be32_to_cpu(lhd->lh_flags);
+ lh->lh_tail = be32_to_cpu(lhd->lh_tail);
+ lh->lh_blkno = be32_to_cpu(lhd->lh_blkno);
+ lh->lh_hash = be32_to_cpu(lhd->lh_hash);
+ lh->lh_crc = be32_to_cpu(lhd->lh_crc);
+ lh->lh_local_total = be64_to_cpu(lhd->lh_local_total);
+ lh->lh_local_free = be64_to_cpu(lhd->lh_local_free);
+ lh->lh_local_dinodes = be64_to_cpu(lhd->lh_local_dinodes);
+}
+
/**
* get_log_header - read the log header for a given segment
* @ip: the journal incore inode
@@ -50,11 +65,12 @@ int gfs2_replay_read_block(struct gfs2_inode *ip, unsigned int blk,
* errno on error
*/
-int get_log_header(struct gfs2_inode *ip, unsigned int blk,
- struct gfs2_log_header *head)
+int lgfs2_get_log_header(struct gfs2_inode *ip, unsigned int blk,
+ struct lgfs2_log_header *head)
{
struct gfs2_buffer_head *bh;
- struct gfs2_log_header lh, *tmp;
+ struct lgfs2_log_header lh;
+ struct gfs2_log_header *tmp;
uint32_t hash, saved_hash;
uint32_t lh_crc = 0;
uint32_t crc;
@@ -70,7 +86,7 @@ int get_log_header(struct gfs2_inode *ip, unsigned int blk,
hash = lgfs2_log_header_hash(bh->b_data);
tmp->lh_hash = saved_hash;
crc = lgfs2_log_header_crc(bh->b_data, ip->i_sbd->bsize);
- gfs2_log_header_in(&lh, bh->b_data);
+ log_header_in(&lh, bh->b_data);
brelse(bh);
lh_crc = lh.lh_crc;
if (error || lh.lh_blkno != blk || lh.lh_hash != hash)
@@ -96,14 +112,14 @@ int get_log_header(struct gfs2_inode *ip, unsigned int blk,
*
* Returns: errno
*/
-static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk, struct gfs2_log_header *head)
+static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk, struct lgfs2_log_header *head)
{
unsigned int orig_blk = *blk;
int error;
uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
for (;;) {
- error = get_log_header(ip, *blk, head);
+ error = lgfs2_get_log_header(ip, *blk, head);
if (error <= 0)
return error;
@@ -126,18 +142,18 @@ static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk, struct gfs2_lo
* Returns: errno
*/
-static int jhead_scan(struct gfs2_inode *ip, struct gfs2_log_header *head)
+static int jhead_scan(struct gfs2_inode *ip, struct lgfs2_log_header *head)
{
unsigned int blk = head->lh_blkno;
uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
- struct gfs2_log_header lh;
+ struct lgfs2_log_header lh;
int error;
for (;;) {
if (++blk == jd_blocks)
blk = 0;
- error = get_log_header(ip, blk, &lh);
+ error = lgfs2_get_log_header(ip, blk, &lh);
if (error < 0)
return error;
if (error == 1)
@@ -165,9 +181,9 @@ static int jhead_scan(struct gfs2_inode *ip, struct gfs2_log_header *head)
* Returns: errno
*/
-int gfs2_find_jhead(struct gfs2_inode *ip, struct gfs2_log_header *head)
+int lgfs2_find_jhead(struct gfs2_inode *ip, struct lgfs2_log_header *head)
{
- struct gfs2_log_header lh_1, lh_m;
+ struct lgfs2_log_header lh_1, lh_m;
uint32_t blk_1, blk_2, blk_m;
uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
int error;
@@ -213,7 +229,7 @@ int gfs2_find_jhead(struct gfs2_inode *ip, struct gfs2_log_header *head)
* Returns: errno
*/
-int clean_journal(struct gfs2_inode *ip, struct gfs2_log_header *head)
+int lgfs2_clean_journal(struct gfs2_inode *ip, struct lgfs2_log_header *head)
{
unsigned int lblock;
struct gfs2_log_header *lh;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
- 1
- 0
[gfs2-utils] 16/40: gfs2_edit: Clean up display_gfs2()
by pagure＠pagure.io
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 fde3c618b64c11eaa75f9b55bc026edc472327b2
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Mon May 10 09:35:36 2021 +0100
gfs2_edit: Clean up display_gfs2()
Now that we have big endian printing functions the gfs2_meta_header_in()
call in display_gfs2() can be removed. Rearrange the function to remove
a level of nesting and an unnecessary switch statement and group the
cases that all call lgfs2_meta_header_print().
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/edit/gfs2hex.c | 132 +++++++++++++++++++++-------------------------------
gfs2/edit/gfs2hex.h | 2 +-
gfs2/edit/hexedit.h | 1 -
3 files changed, 55 insertions(+), 80 deletions(-)
diff --git a/gfs2/edit/gfs2hex.c b/gfs2/edit/gfs2hex.c
index 4c3426db..092b35b6 100644
--- a/gfs2/edit/gfs2hex.c
+++ b/gfs2/edit/gfs2hex.c
@@ -393,94 +393,70 @@ static void gfs_sb_print(void *sbp)
lgfs2_inum_print(&sb->sb_license_di);
}
-int display_gfs2(char *buf)
+void display_gfs2(void *buf)
{
- struct gfs2_meta_header mh;
-
+ struct gfs2_meta_header *mh = buf;
uint32_t magic;
+ uint32_t type;
- magic = be32_to_cpu(*(uint32_t *)buf);
+ magic = be32_to_cpu(mh->mh_magic);
+ type = be32_to_cpu(mh->mh_type);
- switch (magic)
- {
- case GFS2_MAGIC:
- gfs2_meta_header_in(&mh, buf);
- if (mh.mh_type > GFS2_METATYPE_QC)
- print_gfs2("Unknown metadata type");
- else
- print_gfs2("%s:", block_type_str[mh.mh_type]);
+ if (magic != GFS2_MAGIC) {
+ print_gfs2("Unknown block type");
eol(0);
+ return;
+ }
- switch (mh.mh_type)
- {
- case GFS2_METATYPE_SB:
- if (sbd.gfs1)
- gfs_sb_print(buf);
- else
- lgfs2_sb_print(buf);
- break;
- case GFS2_METATYPE_RG:
- if (sbd.gfs1)
- gfs_rgrp_print(buf);
- else
- lgfs2_rgrp_print(buf);
- break;
-
- case GFS2_METATYPE_RB:
- gfs2_meta_header_print(&mh);
- break;
-
- case GFS2_METATYPE_DI:
- lgfs2_dinode_print(di);
- break;
- case GFS2_METATYPE_IN:
- gfs2_meta_header_print(&mh);
- break;
-
- case GFS2_METATYPE_LF:
- lgfs2_leaf_print(buf);
- break;
-
- case GFS2_METATYPE_JD:
- gfs2_meta_header_print(&mh);
- break;
-
- case GFS2_METATYPE_LH:
- if (sbd.gfs1)
- gfs_log_header_print(buf);
- else
- lgfs2_log_header_print(buf);
- break;
-
- case GFS2_METATYPE_LD:
- lgfs2_log_descriptor_print(buf);
- break;
-
- case GFS2_METATYPE_EA:
- do_eattr_extended(buf);
- break;
-
- case GFS2_METATYPE_ED:
- gfs2_meta_header_print(&mh);
- break;
-
- case GFS2_METATYPE_LB:
- gfs2_meta_header_print(&mh);
- break;
-
- case GFS2_METATYPE_QC:
- lgfs2_quota_change_print(buf);
- break;
+ if (type <= GFS2_METATYPE_QC)
+ print_gfs2("%s:", block_type_str[type]);
+ eol(0);
- default:
- break;
- }
+ switch (type)
+ {
+ case GFS2_METATYPE_SB:
+ if (sbd.gfs1)
+ gfs_sb_print(buf);
+ else
+ lgfs2_sb_print(buf);
+ break;
+ case GFS2_METATYPE_RG:
+ if (sbd.gfs1)
+ gfs_rgrp_print(buf);
+ else
+ lgfs2_rgrp_print(buf);
+ break;
+ case GFS2_METATYPE_DI:
+ lgfs2_dinode_print(di);
+ break;
+ case GFS2_METATYPE_LF:
+ lgfs2_leaf_print(buf);
+ break;
+ case GFS2_METATYPE_LH:
+ if (sbd.gfs1)
+ gfs_log_header_print(buf);
+ else
+ lgfs2_log_header_print(buf);
+ break;
+ case GFS2_METATYPE_LD:
+ lgfs2_log_descriptor_print(buf);
+ break;
+ case GFS2_METATYPE_EA:
+ do_eattr_extended(buf);
+ break;
+ case GFS2_METATYPE_QC:
+ lgfs2_quota_change_print(buf);
+ break;
+ case GFS2_METATYPE_RB:
+ case GFS2_METATYPE_IN:
+ case GFS2_METATYPE_JD:
+ case GFS2_METATYPE_ED:
+ case GFS2_METATYPE_LB:
+ lgfs2_meta_header_print(mh);
break;
-
default:
print_gfs2("Unknown block type");
eol(0);
break;
- };
- return(0);
+ }
}
diff --git a/gfs2/edit/gfs2hex.h b/gfs2/edit/gfs2hex.h
index 23b1fc60..a86e3a4c 100644
--- a/gfs2/edit/gfs2hex.h
+++ b/gfs2/edit/gfs2hex.h
@@ -3,7 +3,7 @@
#include "hexedit.h"
-extern int display_gfs2(char *buf);
+extern void display_gfs2(void *buf);
extern int edit_gfs2(void);
extern void do_dinode_extended(char *buf);
extern void print_gfs2(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index cb3343d0..b0ca1fba 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -58,7 +58,6 @@ extern WINDOW *wind;
extern int editing;
extern uint64_t temp_blk;
extern uint64_t starting_blk;
-extern const char *block_type_str[15];
extern int dsplines;
extern int dsp_lines[DMODES];
extern int combined_display;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
- 1
- 0
[gfs2-utils] 15/40: libgfs2: Fix endianness mismatches for struct
gfs2_log_header
by pagure＠pagure.io
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 afa1d8dfbc1e856ebcb9368009681ca18ed8a1ed
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Mon May 10 08:41:13 2021 +0100
libgfs2: Fix endianness mismatches for struct gfs2_log_header
Convert gfs2_log_header_print to accept big-endian data and remove a
bunch of uses of gfs2_log_header_{in,out}. Not all of them can be
removed as some the journal recovery deeply depends on it so that will
require a different approach.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/edit/gfs2hex.c | 13 +++-----
gfs2/edit/hexedit.c | 40 ++++++------------------
gfs2/edit/hexedit.h | 3 +-
gfs2/edit/journal.c | 77 +++++++++++++++++++++++------------------------
gfs2/edit/savemeta.c | 31 ++++++++++---------
gfs2/libgfs2/libgfs2.h | 2 +-
gfs2/libgfs2/ondisk.c | 38 ++++++++++++-----------
gfs2/libgfs2/structures.c | 76 +++++++++++++++++++++-------------------------
gfs2/mkfs/main_jadd.c | 43 ++++++++++++++------------
9 files changed, 149 insertions(+), 174 deletions(-)
diff --git a/gfs2/edit/gfs2hex.c b/gfs2/edit/gfs2hex.c
index 9d5eff71..4c3426db 100644
--- a/gfs2/edit/gfs2hex.c
+++ b/gfs2/edit/gfs2hex.c
@@ -396,8 +396,6 @@ static void gfs_sb_print(void *sbp)
int display_gfs2(char *buf)
{
struct gfs2_meta_header mh;
- struct gfs_log_header lh1;
- struct gfs2_log_header lh;
uint32_t magic;
@@ -448,13 +446,10 @@ int display_gfs2(char *buf)
break;
case GFS2_METATYPE_LH:
- if (sbd.gfs1) {
- gfs_log_header_in(&lh1, buf);
- gfs_log_header_print(&lh1);
- } else {
- gfs2_log_header_in(&lh, buf);
- gfs2_log_header_print(&lh);
- }
+ if (sbd.gfs1)
+ gfs_log_header_print(buf);
+ else
+ lgfs2_log_header_print(buf);
break;
case GFS2_METATYPE_LD:
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index f63dc3ec..2e647211 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -2043,40 +2043,20 @@ static void interactive_mode(void)
endwin();
}/* interactive_mode */
-/* ------------------------------------------------------------------------ */
-/* gfs_log_header_in - read in a gfs1-style log header */
-/* ------------------------------------------------------------------------ */
-void gfs_log_header_in(struct gfs_log_header *head, const char *buf)
-{
- const struct gfs_log_header *str = (void *)buf;
-
- gfs2_meta_header_in(&head->lh_header, buf);
-
- head->lh_flags = be32_to_cpu(str->lh_flags);
- head->lh_pad = be32_to_cpu(str->lh_pad);
-
- head->lh_first = be64_to_cpu(str->lh_first);
- head->lh_sequence = be64_to_cpu(str->lh_sequence);
-
- head->lh_tail = be64_to_cpu(str->lh_tail);
- head->lh_last_dump = be64_to_cpu(str->lh_last_dump);
-
- memcpy(head->lh_reserved, str->lh_reserved, 64);
-}
-
-
/* ------------------------------------------------------------------------ */
/* gfs_log_header_print - print a gfs1-style log header */
/* ------------------------------------------------------------------------ */
-void gfs_log_header_print(struct gfs_log_header *lh)
+void gfs_log_header_print(void *lhp)
{
- gfs2_meta_header_print(&lh->lh_header);
- pv(lh, lh_flags, "%u", "0x%.8x");
- pv(lh, lh_pad, "%u", "%x");
- pv((unsigned long long)lh, lh_first, "%llu", "%llx");
- pv((unsigned long long)lh, lh_sequence, "%llu", "%llx");
- pv((unsigned long long)lh, lh_tail, "%llu", "%llx");
- pv((unsigned long long)lh, lh_last_dump, "%llu", "%llx");
+ struct gfs_log_header *lh = lhp;
+
+ lgfs2_meta_header_print(&lh->lh_header);
+ print_it(" lh_flags", "%"PRIu32, "0x%.8"PRIx32, be32_to_cpu(lh->lh_flags));
+ print_it(" lh_pad", "%"PRIu32, "0x%"PRIx32, be32_to_cpu(lh->lh_pad));
+ print_it(" lh_first", "%"PRIu64, "0x%"PRIx64, be64_to_cpu(lh->lh_first));
+ print_it(" lh_sequence", "%"PRIu64, "0x%"PRIx64, be64_to_cpu(lh->lh_sequence));
+ print_it(" lh_tail", "%"PRIu64, "0x%"PRIx64, be64_to_cpu(lh->lh_tail));
+ print_it(" lh_last_dump", "%"PRIu64, "0x%"PRIx64, be64_to_cpu(lh->lh_last_dump));
}
/* ------------------------------------------------------------------------ */
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index 11e6f105..cb3343d0 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -222,8 +222,7 @@ extern int block_is_quota_file(uint64_t blk);
extern int block_is_per_node(uint64_t blk);
extern int display_block_type(char *buf, uint64_t addr, int from_restore);
extern void gfs_jindex_in(struct gfs_jindex *jindex, char *buf);
-extern void gfs_log_header_in(struct gfs_log_header *head, const char *buf);
-extern void gfs_log_header_print(struct gfs_log_header *lh);
+extern void gfs_log_header_print(void *lhp);
extern void savemeta(char *out_fn, int saveoption, int gziplevel);
extern void restoremeta(const char *in_fn, const char *out_device,
uint64_t printblocksonly);
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index 7f27109a..607f65e5 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -301,7 +301,7 @@ static int print_ld_blks(const uint64_t *b, const char *end, int start_line,
return bcount;
}
-static int is_wrap_pt(char *buf, uint64_t *highest_seq)
+static int is_wrap_pt(void *buf, uint64_t *highest_seq)
{
const struct lgfs2_metadata *mtype = get_block_type(buf);
@@ -309,13 +309,11 @@ static int is_wrap_pt(char *buf, uint64_t *highest_seq)
uint64_t seq;
if (sbd.gfs1) {
- struct gfs_log_header lh;
- gfs_log_header_in(&lh, buf);
- seq = lh.lh_sequence;
+ struct gfs_log_header *lh = buf;
+ seq = be64_to_cpu(lh->lh_sequence);
} else {
- struct gfs2_log_header lh;
- gfs2_log_header_in(&lh, buf);
- seq = lh.lh_sequence;
+ struct gfs2_log_header *lh = buf;
+ seq = be64_to_cpu(lh->lh_sequence);
}
if (seq < *highest_seq)
return 1;
@@ -467,6 +465,38 @@ static uint64_t get_ldref(uint64_t abs_ld, int offset_from_ld)
return refblk;
}
+static void display_log_header(void *buf, uint64_t *highest_seq, uint64_t abs_block, uint64_t jb, uint64_t j_size)
+{
+ const struct lgfs2_metafield *lh_flags_field;
+ const struct lgfs2_metadata *mtype;
+ struct gfs2_log_header *lh = buf;
+ struct gfs_log_header *lh1 = buf;
+ char flags_str[256];
+
+ if (sbd.gfs1) {
+ mtype = &lgfs2_metadata[LGFS2_MT_GFS_LOG_HEADER];
+ lh_flags_field = &mtype->fields[7]; /* lh_flags is the 8th field in the struct */
+ check_journal_wrap(be64_to_cpu(lh1->lh_sequence), highest_seq);
+ } else {
+ mtype = &lgfs2_metadata[LGFS2_MT_GFS2_LOG_HEADER];
+ lh_flags_field = &mtype->fields[6]; /* lh_flags is the 7th field in the struct */
+ check_journal_wrap(be64_to_cpu(lh->lh_sequence), highest_seq);
+ }
+ lgfs2_field_str(flags_str, sizeof(flags_str), buf, lh_flags_field, (dmode == HEX_MODE));
+ if (sbd.gfs1) {
+ print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: Seq: 0x%"PRIx64", "
+ "1st: 0x%"PRIx64", tail: 0x%"PRIx64", last: 0x%"PRIx64" [%s]",
+ abs_block, jb, be64_to_cpu(lh1->lh_sequence),
+ be64_to_cpu(lh1->lh_first), be64_to_cpu(lh1->lh_tail),
+ be64_to_cpu(lh1->lh_last_dump), flags_str);
+ } else {
+ print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: Seq: 0x%"PRIx64", "
+ "tail: 0x%"PRIx32", blk: 0x%"PRIx32" [%s]",
+ abs_block, (jb % j_size) / sbd.bsize, be64_to_cpu(lh->lh_sequence),
+ be32_to_cpu(lh->lh_tail), be32_to_cpu(lh->lh_blkno), flags_str);
+ }
+}
+
/**
* dump_journal - dump a journal file's contents.
* @journal: name of the journal to dump
@@ -480,7 +510,6 @@ static uint64_t get_ldref(uint64_t abs_ld, int offset_from_ld)
void dump_journal(const char *journal, int tblk)
{
const struct lgfs2_metadata *mtype;
- const struct lgfs2_metafield *lh_flags_field;
struct gfs2_buffer_head *j_bh = NULL;
uint64_t jblock, j_size, jb, abs_block, saveblk, wrappt = 0;
int start_line, journal_num;
@@ -494,7 +523,6 @@ void dump_journal(const char *journal, int tblk)
uint64_t abs_ld = 0;
mtype = lgfs2_find_mtype(GFS2_METATYPE_LH, sbd.gfs1 ? LGFS2_MD_GFS1 : LGFS2_MD_GFS2);
- lh_flags_field = lgfs2_find_mfield_name("lh_flags", mtype);
start_line = line;
lines_per_row[dmode] = 1;
@@ -589,36 +617,7 @@ void dump_journal(const char *journal, int tblk)
offset_from_ld = 0;
abs_ld = abs_block;
} else if (!tblk && block_type == GFS2_METATYPE_LH) {
- struct gfs2_log_header lh;
- struct gfs_log_header lh1;
-
- if (sbd.gfs1) {
- gfs_log_header_in(&lh1, buf);
- check_journal_wrap(lh1.lh_sequence,
- &highest_seq);
- print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: "
- "Flags:%"PRIx32", Seq: 0x%"PRIx64", 1st: 0x%"PRIx64", "
- "tail: 0x%"PRIx64", last: 0x%"PRIx64,
- abs_block, jb + wrappt,
- lh1.lh_flags, lh1.lh_sequence,
- lh1.lh_first, lh1.lh_tail,
- lh1.lh_last_dump);
- } else {
- char flags_str[256];
-
- gfs2_log_header_in(&lh, buf);
- check_journal_wrap(lh.lh_sequence,
- &highest_seq);
- lgfs2_field_str(flags_str, sizeof(flags_str),
- buf, lh_flags_field,
- (dmode == HEX_MODE));
- print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: Seq: "
- "0x%"PRIx64", tail: 0x%"PRIx32", blk: 0x%"PRIx32" [%s]",
- abs_block, ((jb + wrappt) % j_size)
- / sbd.bsize, lh.lh_sequence,
- lh.lh_tail, lh.lh_blkno,
- flags_str);
- }
+ display_log_header(buf, &highest_seq, abs_block, jb + wrappt, j_size);
eol(0);
} else if ((ld_blocks > 0) &&
(sbd.gfs1 || block_type == GFS2_METATYPE_LB)) {
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 664c92d6..9c003e68 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -857,15 +857,14 @@ static void save_leaf_blocks(struct metafd *mfd, struct block_range_queue *q)
static void save_inode_data(struct metafd *mfd, char *ibuf, uint64_t iblk)
{
struct block_range_queue indq[GFS2_MAX_META_HEIGHT] = {{NULL}};
- uint32_t height;
- struct gfs2_dinode _di = {0};
+ struct gfs2_dinode *dip = (struct gfs2_dinode *)ibuf;
+ uint16_t height;
int is_exhash;
for (unsigned i = 0; i < GFS2_MAX_META_HEIGHT; i++)
block_range_queue_init(&indq[i]);
- gfs2_dinode_in(&_di, ibuf);
- height = _di.di_height;
+ height = be16_to_cpu(dip->di_height);
/* If this is a user inode, we don't follow to the file height.
We stop one level less. That way we save off the indirect
@@ -873,16 +872,20 @@ static void save_inode_data(struct metafd *mfd, char *ibuf, uint64_t iblk)
is directories, where the height represents the level at which
the hash table exists, and we have to save the directory data. */
- is_exhash = (S_ISDIR(_di.di_mode) || (sbd.gfs1 && _di.__pad1 == GFS_FILE_DIR)) &&
- _di.di_flags & GFS2_DIF_EXHASH;
+ is_exhash = (S_ISDIR(be32_to_cpu(dip->di_mode)) ||
+ (sbd.gfs1 && be16_to_cpu(dip->__pad1) == GFS_FILE_DIR)) &&
+ be32_to_cpu(dip->di_flags) & GFS2_DIF_EXHASH;
if (is_exhash)
height++;
- else if (height > 0 && !(_di.di_flags & GFS2_DIF_SYSTEM) &&
- !block_is_systemfile(iblk) && !S_ISDIR(_di.di_mode))
+ else if (height > 0 && !(be32_to_cpu(dip->di_flags) & GFS2_DIF_SYSTEM) &&
+ !block_is_systemfile(iblk) && !S_ISDIR(be32_to_cpu(dip->di_mode)))
height--;
- if (height > 0)
- save_indirect_blocks(mfd, ibuf, iblk, height == 1 ? NULL : &indq[0], sizeof(_di));
+ if (height == 1)
+ save_indirect_blocks(mfd, ibuf, iblk, NULL, sizeof(*dip));
+ else if (height > 1)
+ save_indirect_blocks(mfd, ibuf, iblk, &indq[0], sizeof(*dip));
+
for (unsigned i = 1; i < height; i++) {
struct block_range_queue *nextq = &indq[i];
@@ -895,7 +898,7 @@ static void save_inode_data(struct metafd *mfd, char *ibuf, uint64_t iblk)
for (unsigned j = 0; j < q->len; j++) {
char *_buf = q->buf + (j * sbd.bsize);
- save_indirect_blocks(mfd, _buf, iblk, nextq, sizeof(_di.di_header));
+ save_indirect_blocks(mfd, _buf, iblk, nextq, sizeof(dip->di_header));
}
report_progress(q->start + q->len, 0);
block_range_free(&q);
@@ -903,20 +906,20 @@ static void save_inode_data(struct metafd *mfd, char *ibuf, uint64_t iblk)
}
if (is_exhash)
save_leaf_blocks(mfd, &indq[height - 1]);
- if (_di.di_eattr) { /* if this inode has extended attributes */
+ if (dip->di_eattr) { /* if this inode has extended attributes */
size_t blklen;
uint64_t blk;
int mhtype;
char *buf;
- blk = _di.di_eattr;
+ blk = be64_to_cpu(dip->di_eattr);
buf = check_read_block(sbd.device_fd, blk, iblk, &mhtype, &blklen);
if (buf != NULL) {
save_buf(mfd, buf, blk, blklen);
if (mhtype == GFS2_METATYPE_EA)
save_ea_block(mfd, buf, iblk);
else if (mhtype == GFS2_METATYPE_IN)
- save_indirect_blocks(mfd, buf, iblk, NULL, sizeof(_di.di_header));
+ save_indirect_blocks(mfd, buf, iblk, NULL, sizeof(dip->di_header));
free(buf);
}
}
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index 594db181..922d35f8 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -720,12 +720,12 @@ 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);
extern void gfs2_dinode_print(const struct gfs2_dinode *di);
-extern void gfs2_log_header_print(const struct gfs2_log_header *lh);
/* 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);
extern void lgfs2_sb_print(void *sbp);
extern void lgfs2_dinode_print(void *dip);
+extern void lgfs2_log_header_print(void *lhp);
extern void lgfs2_log_descriptor_print(void *ldp);
extern void lgfs2_quota_print(void *qp);
extern void lgfs2_quota_change_print(void *qcp);
diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c
index a7f87d7a..b9b8a67e 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -551,24 +551,26 @@ void gfs2_log_header_out(struct gfs2_log_header *lh, char *buf)
CPOUT_64(lh, str, lh_local_dinodes);
}
-void gfs2_log_header_print(const struct gfs2_log_header *lh)
-{
- gfs2_meta_header_print(&lh->lh_header);
- pv(lh, lh_sequence, "%"PRIu64, "0x%"PRIx64);
- pv(lh, lh_flags, "0x%.8"PRIX32, NULL);
- pv(lh, lh_tail, "%"PRIu32, "0x%"PRIx32);
- pv(lh, lh_blkno, "%"PRIu32, "0x%"PRIx32);
- pv(lh, lh_hash, "0x%.8"PRIX32, NULL);
- pv(lh, lh_crc, "0x%.8"PRIX32, NULL);
- pv(lh, lh_nsec, "%"PRIu32, "0x%"PRIx32);
- pv(lh, lh_sec, "%"PRIu64, "0x%"PRIx64);
- pv(lh, lh_addr, "%"PRIu64, "0x%"PRIx64);
- pv(lh, lh_jinode, "%"PRIu64, "0x%"PRIx64);
- pv(lh, lh_statfs_addr, "%"PRIu64, "0x%"PRIx64);
- pv(lh, lh_quota_addr, "%"PRIu64, "0x%"PRIx64);
- pv(lh, lh_local_total, "%"PRId64, "0x%"PRIx64);
- pv(lh, lh_local_free, "%"PRId64, "0x%"PRIx64);
- pv(lh, lh_local_dinodes, "%"PRId64, "0x%"PRIx64);
+void lgfs2_log_header_print(void *lhp)
+{
+ struct gfs2_log_header *lh = lhp;
+
+ lgfs2_meta_header_print(&lh->lh_header);
+ printbe64(lh, lh_sequence);
+ print_it(" lh_flags", "0x%.8"PRIX32, NULL, be32_to_cpu(lh->lh_flags));
+ printbe32(lh, lh_tail);
+ printbe32(lh, lh_blkno);
+ print_it(" lh_hash", "0x%.8"PRIX32, NULL, be32_to_cpu(lh->lh_hash));
+ print_it(" lh_crc", "0x%.8"PRIX32, NULL, be32_to_cpu(lh->lh_crc));
+ printbe32(lh, lh_nsec);
+ printbe64(lh, lh_sec);
+ printbe64(lh, lh_addr);
+ printbe64(lh, lh_jinode);
+ printbe64(lh, lh_statfs_addr);
+ printbe64(lh, lh_quota_addr);
+ print_it(" lh_local_total", "%"PRId64, "0x%"PRIx64, be64_to_cpu(lh->lh_local_total));
+ print_it(" lh_local_free", "%"PRId64, "0x%"PRIx64, be64_to_cpu(lh->lh_local_free));
+ print_it(" lh_local_dinodes", "%"PRId64, "0x%"PRIx64, be64_to_cpu(lh->lh_local_dinodes));
}
void lgfs2_log_descriptor_print(void *ldp)
diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c
index 79d99ba1..4ef4e685 100644
--- a/gfs2/libgfs2/structures.c
+++ b/gfs2/libgfs2/structures.c
@@ -124,28 +124,11 @@ uint32_t lgfs2_log_header_crc(char *buf, unsigned bsize)
*/
int lgfs2_write_journal_data(struct gfs2_inode *ip)
{
- struct gfs2_log_header lh = {
- .lh_header.mh_magic = GFS2_MAGIC,
- .lh_header.mh_type = GFS2_METATYPE_LH,
- .lh_header.mh_format = GFS2_FORMAT_LH,
- .lh_tail = 0,
- .lh_blkno = 0,
- .lh_hash = 0,
- .lh_flags = GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_USERSPACE,
- .lh_crc = 0,
- .lh_nsec = 0,
- .lh_sec = 0,
- .lh_jinode = ip->i_di.di_num.no_addr,
- .lh_statfs_addr = 0,
- .lh_quota_addr = 0,
- .lh_local_total = 0,
- .lh_local_free = 0,
- .lh_local_dinodes = 0,
- };
struct gfs2_sbd *sdp = ip->i_sbd;
unsigned blocks = (ip->i_di.di_size + sdp->bsize - 1) / sdp->bsize;
uint64_t jext0 = ip->i_di.di_num.no_addr + ip->i_di.di_blocks - blocks;
uint64_t seq = ((blocks) * (random() / (RAND_MAX + 1.0)));
+ struct gfs2_log_header *lh;
uint64_t jblk = jext0;
char *buf;
@@ -153,23 +136,33 @@ int lgfs2_write_journal_data(struct gfs2_inode *ip)
if (buf == NULL)
return -1;
+ lh = (void *)buf;
+ lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
+ lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
+ lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
+ lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_USERSPACE);
+ lh->lh_jinode = cpu_to_be64(ip->i_di.di_num.no_addr);
+
crc32c_optimization_init();
do {
- struct gfs2_log_header *buflh = (struct gfs2_log_header *)buf;
-
- lh.lh_sequence = seq;
- lh.lh_blkno = jblk - jext0;
- gfs2_log_header_out(&lh, buf);
+ uint32_t hash;
- buflh->lh_hash = cpu_to_be32(lgfs2_log_header_hash(buf));
- buflh->lh_addr = cpu_to_be64(jblk);
- buflh->lh_crc = cpu_to_be32(lgfs2_log_header_crc(buf, sdp->bsize));
+ lh->lh_sequence = cpu_to_be64(seq);
+ lh->lh_blkno = cpu_to_be32(jblk - jext0);
+ hash = lgfs2_log_header_hash(buf);
+ lh->lh_hash = cpu_to_be32(hash);
+ lh->lh_addr = cpu_to_be64(jblk);
+ hash = lgfs2_log_header_crc(buf, sdp->bsize);
+ lh->lh_crc = cpu_to_be32(hash);
if (pwrite(sdp->device_fd, buf, sdp->bsize, jblk * sdp->bsize) != sdp->bsize) {
free(buf);
return -1;
}
+ lh->lh_crc = 0;
+ lh->lh_hash = 0;
+
if (++seq == blocks)
seq = 0;
@@ -205,8 +198,8 @@ static struct gfs2_buffer_head *get_file_buf(struct gfs2_inode *ip, uint64_t lbn
int write_journal(struct gfs2_inode *jnl, unsigned bsize, unsigned int blocks)
{
- struct gfs2_log_header lh;
- unsigned int x;
+ struct gfs2_log_header *lh;
+ uint32_t x;
uint64_t seq = ((blocks) * (random() / (RAND_MAX + 1.0)));
uint32_t hash;
unsigned int height;
@@ -216,14 +209,6 @@ int write_journal(struct gfs2_inode *jnl, unsigned bsize, unsigned int blocks)
height = calc_tree_height(jnl, (blocks + 1) * bsize);
build_height(jnl, height);
- memset(&lh, 0, sizeof(struct gfs2_log_header));
- lh.lh_header.mh_magic = GFS2_MAGIC;
- lh.lh_header.mh_type = GFS2_METATYPE_LH;
- lh.lh_header.mh_format = GFS2_FORMAT_LH;
- lh.lh_flags = GFS2_LOG_HEAD_UNMOUNT;
- lh.lh_flags |= GFS2_LOG_HEAD_USERSPACE;
- lh.lh_jinode = jnl->i_di.di_num.no_addr;
-
for (x = 0; x < blocks; x++) {
struct gfs2_buffer_head *bh = get_file_buf(jnl, x, 1);
if (!bh)
@@ -238,14 +223,21 @@ int write_journal(struct gfs2_inode *jnl, unsigned bsize, unsigned int blocks)
return -1;
memset(bh->b_data, 0, bsize);
- lh.lh_sequence = seq;
- lh.lh_blkno = x;
- gfs2_log_header_out(&lh, bh->b_data);
+ lh = (void *)bh->b_data;
+ lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
+ lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
+ lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
+ lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_USERSPACE);
+ lh->lh_jinode = cpu_to_be64(jnl->i_di.di_num.no_addr);
+ lh->lh_sequence = cpu_to_be64(seq);
+ lh->lh_blkno = cpu_to_be32(x);
+
hash = lgfs2_log_header_hash(bh->b_data);
- ((struct gfs2_log_header *)bh->b_data)->lh_hash = cpu_to_be32(hash);
- ((struct gfs2_log_header *)bh->b_data)->lh_addr = cpu_to_be64(bh->b_blocknr);
+ lh->lh_hash = cpu_to_be32(hash);
+ lh->lh_addr = cpu_to_be64(bh->b_blocknr);
+
hash = lgfs2_log_header_crc(bh->b_data, bsize);
- ((struct gfs2_log_header *)bh->b_data)->lh_crc = cpu_to_be32(hash);
+ lh->lh_crc = cpu_to_be32(hash);
bmodified(bh);
brelse(bh);
diff --git a/gfs2/mkfs/main_jadd.c b/gfs2/mkfs/main_jadd.c
index bad7db25..8e349c9c 100644
--- a/gfs2/mkfs/main_jadd.c
+++ b/gfs2/mkfs/main_jadd.c
@@ -517,16 +517,20 @@ out_errno:
static int add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
{
int fd, error = 0;
- char new_name[256], buf[sdp->bsize];
- unsigned int x, blocks =
- sdp->jsize << (20 - sdp->sd_sb.sb_bsize_shift);
- struct gfs2_log_header lh;
+ char new_name[256], *buf;
+ uint32_t x, blocks = sdp->jsize << (20 - sdp->sd_sb.sb_bsize_shift);
+ struct gfs2_log_header *lh;
uint64_t seq = RANDOM(blocks), addr = 0;
off_t off = 0;
- if ((fd = create_new_inode(opts, &addr)) < 0)
- return fd;
+ buf = calloc(1, sdp->bsize);
+ if (buf == NULL)
+ return -1;
+ if ((fd = create_new_inode(opts, &addr)) < 0) {
+ free(buf);
+ return fd;
+ }
if ((error = set_flags(fd, JA_FL_CLEAR, FS_JOURNAL_DATA_FL)))
goto close_fd;
@@ -544,34 +548,34 @@ static int add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
goto close_fd;
}
- memset(&lh, 0, sizeof(struct gfs2_log_header));
- lh.lh_header.mh_magic = GFS2_MAGIC;
- lh.lh_header.mh_type = GFS2_METATYPE_LH;
- lh.lh_header.mh_format = GFS2_FORMAT_LH;
- lh.lh_flags = GFS2_LOG_HEAD_UNMOUNT;
- lh.lh_flags |= GFS2_LOG_HEAD_USERSPACE;
- lh.lh_jinode = addr;
+ lh = (void *)buf;
+ lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
+ lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
+ lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
+ lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_USERSPACE);
+ lh->lh_jinode = cpu_to_be64(addr);
for (x=0; x<blocks; x++) {
uint32_t hash;
uint64_t blk_addr = 0;
- lh.lh_sequence = seq;
- lh.lh_blkno = x;
- gfs2_log_header_out(&lh, buf);
+ lh->lh_sequence = cpu_to_be64(seq);
+ lh->lh_blkno = cpu_to_be32(x);
hash = lgfs2_log_header_hash(buf);
- ((struct gfs2_log_header *)buf)->lh_hash = cpu_to_be32(hash);
+ lh->lh_hash = cpu_to_be32(hash);
if (!(blk_addr = find_block_address(fd, off, sdp->bsize))) {
error = -1;
goto close_fd;
}
- ((struct gfs2_log_header *)buf)->lh_addr = cpu_to_be64(blk_addr);
+ lh->lh_addr = cpu_to_be64(blk_addr);
hash = lgfs2_log_header_crc(buf, sdp->bsize);
- ((struct gfs2_log_header *)buf)->lh_crc = cpu_to_be32(hash);
+ lh->lh_crc = cpu_to_be32(hash);
if (write(fd, buf, sdp->bsize) != sdp->bsize) {
perror("add_j write");
error = -1;
goto close_fd;
}
+ lh->lh_crc = 0;
+ lh->lh_hash = 0;
if (++seq == blocks)
seq = 0;
@@ -590,6 +594,7 @@ static int add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
goto close_fd;
}
close_fd:
+ free(buf);
return close(fd) || error;
}
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
- 1
- 0
[gfs2-utils] 14/40: libgfs2: Don't use on-disk structs with
cpu-endian data in __init_dinode
by pagure＠pagure.io
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 204902708dcdd5349b8b770aa3c14fc4ead87ae7
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Wed Apr 28 20:45:17 2021 +0100
libgfs2: Don't use on-disk structs with cpu-endian data in __init_dinode
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/libgfs2/fs_ops.c | 93 ++++++++++++++++++++++++++-------------------------
1 file changed, 48 insertions(+), 45 deletions(-)
diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index 27fb43cb..12d845f1 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
@@ -1330,7 +1330,7 @@ static int __init_dinode(struct gfs2_sbd *sdp, struct gfs2_buffer_head **bhp, st
unsigned int mode, uint32_t flags, struct gfs2_inum *parent, int gfs1)
{
struct gfs2_buffer_head *bh;
- struct gfs2_dinode di = {{0}};
+ struct gfs2_dinode *di;
int is_dir;
if (gfs1)
@@ -1350,53 +1350,56 @@ static int __init_dinode(struct gfs2_sbd *sdp, struct gfs2_buffer_head **bhp, st
bh = *bhp;
- di.di_header.mh_magic = GFS2_MAGIC;
- di.di_header.mh_type = GFS2_METATYPE_DI;
- di.di_header.mh_format = GFS2_FORMAT_DI;
- di.di_num = *inum;
- di.di_mode = mode;
- di.di_nlink = 1;
- di.di_blocks = 1;
- di.di_atime = di.di_mtime = di.di_ctime = sdp->time;
- di.di_goal_meta = di.di_goal_data = bh->b_blocknr;
- di.di_flags = flags;
+ di = (struct gfs2_dinode *)bh->b_data;
+
+ di->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
+ di->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI);
+ di->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI);
+ di->di_num.no_formal_ino = cpu_to_be64(inum->no_formal_ino);
+ di->di_num.no_addr = cpu_to_be64(inum->no_addr);
+ di->di_mode = cpu_to_be32(mode);
+ di->di_nlink = cpu_to_be32(1);
+ di->di_blocks = cpu_to_be64(1);
+ di->di_atime = di->di_mtime = di->di_ctime = cpu_to_be64(sdp->time);
+ di->di_goal_meta = di->di_goal_data = cpu_to_be64(bh->b_blocknr);
+ di->di_flags = cpu_to_be32(flags);
if (is_dir) {
- struct gfs2_dirent de1, de2;
-
- memset(&de1, 0, sizeof(struct gfs2_dirent));
- de1.de_inum = di.di_num;
- de1.de_hash = gfs2_disk_hash(".", 1);
- de1.de_rec_len = GFS2_DIRENT_SIZE(1);
- de1.de_name_len = 1;
- de1.de_type = (gfs1 ? GFS_FILE_DIR : IF2DT(S_IFDIR));
-
- memset(&de2, 0, sizeof(struct gfs2_dirent));
- de2.de_inum = *parent;
- de2.de_hash = gfs2_disk_hash("..", 2);
- de2.de_rec_len = sdp->bsize - sizeof(struct gfs2_dinode) - de1.de_rec_len;
- de2.de_name_len = 2;
- de2.de_type = (gfs1 ? GFS_FILE_DIR : IF2DT(S_IFDIR));
-
- gfs2_dirent_out(&de1, bh->b_data + sizeof(struct gfs2_dinode));
- memcpy(bh->b_data +
- sizeof(struct gfs2_dinode) +
- sizeof(struct gfs2_dirent),
- ".", 1);
- gfs2_dirent_out(&de2, bh->b_data + sizeof(struct gfs2_dinode) + de1.de_rec_len);
- memcpy(bh->b_data +
- sizeof(struct gfs2_dinode) +
- de1.de_rec_len +
- sizeof(struct gfs2_dirent),
- "..", 2);
-
- di.di_nlink = 2;
- di.di_size = sdp->bsize - sizeof(struct gfs2_dinode);
- di.di_flags |= GFS2_DIF_JDATA;
- di.di_payload_format = GFS2_FORMAT_DE;
- di.di_entries = 2;
+ char *p = bh->b_data + sizeof(*di);
+ struct gfs2_dirent de = {0};
+ uint32_t hash;
+ uint16_t len;
+
+ hash = gfs2_disk_hash(".", 1);
+ len = GFS2_DIRENT_SIZE(1);
+ de.de_inum = di->di_num;
+ de.de_hash = cpu_to_be32(hash);
+ de.de_rec_len = cpu_to_be16(len);
+ de.de_name_len = cpu_to_be16(1);
+ de.de_type = cpu_to_be16(gfs1 ? GFS_FILE_DIR : IF2DT(S_IFDIR));
+ memcpy(p, &de, sizeof(de));
+ p[sizeof(de)] = '.';
+ p += len;
+
+ hash = gfs2_disk_hash("..", 2);
+ len = sdp->bsize - (p - bh->b_data);
+ de.de_inum.no_formal_ino = cpu_to_be64(parent->no_formal_ino);
+ de.de_inum.no_addr = cpu_to_be64(parent->no_addr);
+ de.de_hash = cpu_to_be32(hash);
+ de.de_rec_len = cpu_to_be16(len);
+ de.de_name_len = cpu_to_be16(2);
+ de.de_type = cpu_to_be16(gfs1 ? GFS_FILE_DIR : IF2DT(S_IFDIR));
+ memcpy(p, &de, sizeof(de));
+ p += sizeof(de);
+ *p++ = '.';
+ *p = '.';
+
+ di->di_nlink = cpu_to_be32(2);
+ di->di_size = cpu_to_be64(sdp->bsize - sizeof(struct gfs2_dinode));
+ di->di_flags = cpu_to_be32(flags | GFS2_DIF_JDATA);
+ di->di_payload_format = cpu_to_be32(GFS2_FORMAT_DE);
+ di->di_entries = cpu_to_be32(2);
}
- gfs2_dinode_out(&di, bh->b_data);
bmodified(bh);
return 0;
}
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
- 1
- 0
[gfs2-utils] 13/40: gfs2_edit: Store big-endian data in the global
dinode
by pagure＠pagure.io
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 940a709ae2510ae9bd8e6a8f191d0a0e8186aae7
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Wed Apr 28 12:42:53 2021 +0100
gfs2_edit: Store big-endian data in the global dinode
Add a big-endian lgfs2_dinode_print() function to libgfs2 to enable
that.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/edit/extended.c | 21 +++++++++++----------
gfs2/edit/gfs2hex.c | 30 ++++++++++++++++--------------
gfs2/edit/gfs2hex.h | 2 +-
gfs2/edit/hexedit.c | 41 +++++++++++++++++++++++------------------
gfs2/edit/hexedit.h | 2 +-
gfs2/edit/journal.c | 5 ++---
gfs2/edit/savemeta.c | 2 +-
gfs2/libgfs2/libgfs2.h | 1 +
gfs2/libgfs2/ondisk.c | 28 ++++++++++++++++++++++++++++
9 files changed, 84 insertions(+), 48 deletions(-)
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index 7050a36a..4e8a003d 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -103,13 +103,14 @@ static uint64_t metapath_to_lblock(struct metapath *mp, int hgt)
int h;
uint64_t lblock = 0;
uint64_t factor[GFS2_MAX_META_HEIGHT];
+ uint16_t height = be16_to_cpu(di->di_height);
- if (di.di_height < 2)
+ if (height < 2)
return mp->mp_list[0];
/* figure out multiplication factors for each height */
memset(&factor, 0, sizeof(factor));
- factor[di.di_height - 1] = 1ull;
- for (h = di.di_height - 2; h >= 0; h--)
+ factor[height - 1] = 1ull;
+ for (h = height - 2; h >= 0; h--)
factor[h] = factor[h + 1] * sbd.sd_inptrs;
for (h = 0; h <= hgt; h++)
lblock += (mp->mp_list[h] * factor[h]);
@@ -127,7 +128,7 @@ static int display_indirect(struct iinfo *ind, int indblocks, int level,
return -1;
if (!level) {
if (gfs2_struct_type == GFS2_METATYPE_DI) {
- if (S_ISDIR(di.di_mode))
+ if (S_ISDIR(be32_to_cpu(di->di_mode)))
print_gfs2("This directory contains %d indirect blocks",
indblocks);
else
@@ -137,14 +138,14 @@ static int display_indirect(struct iinfo *ind, int indblocks, int level,
print_gfs2("This indirect block contains %d indirect blocks",
indblocks);
}
- if (dinode_valid() && !S_ISDIR(di.di_mode)) {
+ if (dinode_valid() && !S_ISDIR(be32_to_cpu(di->di_mode))) {
/* See if we are on an inode or have one in history. */
if (level)
cur_height = level;
else {
cur_height = get_height();
print_gfs2(" (at height %d of %d)",
- cur_height, di.di_height);
+ cur_height, be16_to_cpu(di->di_height));
}
}
eol(0);
@@ -189,7 +190,7 @@ static int display_indirect(struct iinfo *ind, int indblocks, int level,
COLORS_NORMAL;
}
}
- if (dinode_valid() && !S_ISDIR(di.di_mode)) {
+ if (dinode_valid() && !S_ISDIR(be32_to_cpu(di->di_mode))) {
float human_off;
char h;
@@ -211,8 +212,8 @@ static int display_indirect(struct iinfo *ind, int indblocks, int level,
else
file_offset = 0;
if (dinode_valid() && !termlines &&
- ((level + 1 < di.di_height) ||
- (S_ISDIR(di.di_mode) && level <= di.di_height))) {
+ ((level + 1 < be16_to_cpu(di->di_height)) ||
+ (S_ISDIR(be32_to_cpu(di->di_mode)) && level <= be16_to_cpu(di->di_height)))) {
print_block_details(ind, level, cur_height, pndx,
file_offset);
}
@@ -394,7 +395,7 @@ static void print_block_details(struct iinfo *ind, int level, int cur_height,
}
thisblk = 0;
memset(more_indir, 0, sizeof(struct iinfo));
- if (S_ISDIR(di.di_mode) && level == di.di_height) {
+ if (S_ISDIR(be32_to_cpu(di->di_mode)) && level == be16_to_cpu(di->di_height)) {
thisblk = do_leaf_extended(tmpbuf, more_indir);
display_leaf(more_indir);
} else {
diff --git a/gfs2/edit/gfs2hex.c b/gfs2/edit/gfs2hex.c
index 021c7308..9d5eff71 100644
--- a/gfs2/edit/gfs2hex.c
+++ b/gfs2/edit/gfs2hex.c
@@ -27,7 +27,7 @@
print_it(" "#member, "%"PRIu32, "0x%"PRIx32, be32_to_cpu(struct->member)); \
} while(0)
-struct gfs2_dinode di;
+struct gfs2_dinode *di;
int line, termlines, modelines[DMODES];
char edit_fmt[80];
char estring[1024];
@@ -231,16 +231,20 @@ static int indirect_dirent(struct indirect_info *indir, char *ptr, int d)
return de.de_rec_len;
}
-void do_dinode_extended(struct gfs2_dinode *dine, char *buf)
+void do_dinode_extended(char *buf)
{
+ struct gfs2_dinode *dip = (void *)buf;
unsigned int x, y, ptroff = 0;
uint64_t p, last;
- int isdir = !!(S_ISDIR(dine->di_mode)) ||
- (sbd.gfs1 && dine->__pad1 == GFS_FILE_DIR);
+ int isdir = 0;
+
+ if (S_ISDIR(be32_to_cpu(dip->di_mode)) ||
+ (sbd.gfs1 && be16_to_cpu(dip->__pad1) == GFS_FILE_DIR))
+ isdir = 1;
indirect_blocks = 0;
memset(indirect, 0, sizeof(struct iinfo));
- if (dine->di_height > 0) {
+ if (be16_to_cpu(dip->di_height) > 0) {
/* Indirect pointers */
for (x = sizeof(struct gfs2_dinode); x < sbd.bsize;
x += sizeof(uint64_t)) {
@@ -251,13 +255,13 @@ void do_dinode_extended(struct gfs2_dinode *dine, char *buf)
ptroff;
indirect->ii[indirect_blocks].is_dir = FALSE;
indirect->ii[indirect_blocks].ptroff =
- (x - sizeof(*dine)) / sizeof(uint64_t);
+ (x - sizeof(*dip)) / sizeof(uint64_t);
indirect_blocks++;
}
ptroff++;
}
}
- else if (isdir && !(dine->di_flags & GFS2_DIF_EXHASH)) {
+ else if (isdir && !(be32_to_cpu(dip->di_flags) & GFS2_DIF_EXHASH)) {
int skip = 0;
/* Directory Entries: */
@@ -271,19 +275,18 @@ void do_dinode_extended(struct gfs2_dinode *dine, char *buf)
break;
}
}
- else if (isdir &&
- (dine->di_flags & GFS2_DIF_EXHASH) &&
- dine->di_height == 0) {
+ else if (isdir && (be32_to_cpu(dip->di_flags) & GFS2_DIF_EXHASH) &&
+ dip->di_height == 0) {
/* Leaf Pointers: */
last = be64_to_cpu(*(uint64_t *)(buf + sizeof(struct gfs2_dinode)));
for (x = sizeof(struct gfs2_dinode), y = 0;
- y < (1 << dine->di_depth);
+ y < (1 << be16_to_cpu(dip->di_depth));
x += sizeof(uint64_t), y++) {
p = be64_to_cpu(*(uint64_t *)(buf + x));
- if (p != last || ((y + 1) * sizeof(uint64_t) == dine->di_size)) {
+ if (p != last || ((y + 1) * sizeof(uint64_t) == be64_to_cpu(dip->di_size))) {
struct gfs2_buffer_head *tmp_bh;
int skip = 0, direntcount = 0;
struct gfs2_leaf leaf;
@@ -430,9 +433,8 @@ int display_gfs2(char *buf)
break;
case GFS2_METATYPE_DI:
- gfs2_dinode_print(&di);
+ lgfs2_dinode_print(di);
break;
-
case GFS2_METATYPE_IN:
gfs2_meta_header_print(&mh);
break;
diff --git a/gfs2/edit/gfs2hex.h b/gfs2/edit/gfs2hex.h
index 878ab801..23b1fc60 100644
--- a/gfs2/edit/gfs2hex.h
+++ b/gfs2/edit/gfs2hex.h
@@ -5,7 +5,7 @@
extern int display_gfs2(char *buf);
extern int edit_gfs2(void);
-extern void do_dinode_extended(struct gfs2_dinode *di, char *buf);
+extern void do_dinode_extended(char *buf);
extern void print_gfs2(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
extern uint64_t do_leaf_extended(char *dlebuf, struct iinfo *indir);
extern void eol(int col);
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index c497c748..f63dc3ec 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -497,7 +497,7 @@ static int get_pnum(int ptroffset)
/* ------------------------------------------------------------------------ */
/* hexdump - hex dump the filesystem block to the screen */
/* ------------------------------------------------------------------------ */
-static int hexdump(uint64_t startaddr, int len, int trunc_zeros,
+static int hexdump(uint64_t startaddr, uint64_t len, int trunc_zeros,
uint64_t flagref, uint64_t ref_blk)
{
const unsigned char *pointer, *ptr2;
@@ -537,7 +537,7 @@ static int hexdump(uint64_t startaddr, int len, int trunc_zeros,
if (l < struct_len)
COLORS_NORMAL; /* normal part of structure */
else if (gfs2_struct_type == GFS2_METATYPE_DI &&
- l < struct_len + di.di_size)
+ l < struct_len + be64_to_cpu(di->di_size))
COLORS_CONTENTS; /* after struct but not eof */
else
COLORS_SPECIAL; /* beyond end of the struct */
@@ -548,8 +548,9 @@ static int hexdump(uint64_t startaddr, int len, int trunc_zeros,
/* Figure out if we have a null pointer--for colors */
if (((gfs2_struct_type == GFS2_METATYPE_IN) ||
(gfs2_struct_type == GFS2_METATYPE_DI &&
- l < struct_len + di.di_size &&
- (di.di_height > 0 || !S_ISREG(di.di_mode)))) &&
+ l < struct_len + be64_to_cpu(di->di_size) &&
+ (be16_to_cpu(di->di_height) > 0 ||
+ !S_ISREG(be32_to_cpu(di->di_mode))))) &&
(i==0 || i==8)) {
int j;
@@ -565,9 +566,9 @@ static int hexdump(uint64_t startaddr, int len, int trunc_zeros,
if (l + i < struct_len)
COLORS_NORMAL; /* in the structure */
else if (gfs2_struct_type == GFS2_METATYPE_DI
- && l + i < struct_len + di.di_size) {
- if ((!di.di_height &&
- S_ISREG(di.di_mode)) ||
+ && l + i < struct_len + be64_to_cpu(di->di_size)) {
+ if ((!di->di_height &&
+ S_ISREG(be32_to_cpu(di->di_mode))) ||
!ptr_not_null)
COLORS_CONTENTS;/*stuff data */
else
@@ -632,7 +633,7 @@ static int hexdump(uint64_t startaddr, int len, int trunc_zeros,
block_type == GFS2_METATYPE_LD ||
((block_type == GFS2_METATYPE_DI) &&
((struct gfs2_dinode*)bh->b_data)->di_height) ||
- S_ISDIR(di.di_mode)) {
+ S_ISDIR(be32_to_cpu(di->di_mode))) {
ptroffset = edit_row[dmode] * 16 +
edit_col[dmode];
@@ -822,7 +823,8 @@ int has_indirect_blocks(void)
if (indirect_blocks || gfs2_struct_type == GFS2_METATYPE_SB ||
gfs2_struct_type == GFS2_METATYPE_LF ||
(gfs2_struct_type == GFS2_METATYPE_DI &&
- (S_ISDIR(di.di_mode) || (sbd.gfs1 && di.__pad1 == GFS_FILE_DIR))))
+ (S_ISDIR(be32_to_cpu(di->di_mode)) ||
+ (sbd.gfs1 && be16_to_cpu(di->__pad1) == GFS_FILE_DIR))))
return TRUE;
return FALSE;
}
@@ -986,8 +988,8 @@ static int read_master_dir(void)
bh = bread(&sbd, sbd.sd_sb.sb_master_dir.no_addr);
if (bh == NULL)
return 1;
- gfs2_dinode_in(&di, bh->b_data);
- do_dinode_extended(&di, bh->b_data); /* get extended data, if any */
+ di = (struct gfs2_dinode *)bh->b_data;
+ do_dinode_extended(bh->b_data); /* get extended data, if any */
memcpy(&masterdir, &indirect[0], sizeof(struct indirect_info));
return 0;
}
@@ -1057,8 +1059,8 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
indirect->ii[0].dirent[1].dirent.de_type = DT_DIR;
}
else if (gfs2_struct_type == GFS2_METATYPE_DI) {
- gfs2_dinode_in(&di, bh->b_data);
- do_dinode_extended(&di, bh->b_data); /* get extended data, if any */
+ di = (struct gfs2_dinode *)bh->b_data;
+ do_dinode_extended(bh->b_data); /* get extended data, if any */
}
else if (gfs2_struct_type == GFS2_METATYPE_IN) { /* indirect block list */
if (blockhist) {
@@ -1087,11 +1089,14 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
"Pointers "));
move(line, 0);
}
- if (dmode == HEX_MODE) /* if hex display mode */
- hexdump(dev_offset, (gfs2_struct_type == GFS2_METATYPE_DI)?
- struct_len + di.di_size:sbd.bsize, trunc_zeros,
- flagref, ref_blk);
- else if (dmode == GFS2_MODE) { /* if structure display */
+ if (dmode == HEX_MODE) { /* if hex display mode */
+ uint64_t len = sbd.bsize;
+
+ if (gfs2_struct_type == GFS2_METATYPE_DI)
+ len = struct_len + be64_to_cpu(di->di_size);
+
+ hexdump(dev_offset, len, trunc_zeros, flagref, ref_blk);
+ } else if (dmode == GFS2_MODE) { /* if structure display */
if (block != JOURNALS_DUMMY_BLOCK)
display_gfs2(bh->b_data);
} else
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index f44ea3b1..11e6f105 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -49,7 +49,7 @@ extern struct gfs2_sbd sbd;
extern struct gfs_sb *sbd1;
extern struct gfs2_inum gfs1_quota_di; /* kludge because gfs2 sb too small */
extern struct gfs2_inum gfs1_license_di; /* kludge because gfs2 sb too small */
-extern struct gfs2_dinode di;
+extern struct gfs2_dinode *di;
extern int screen_chunk_size; /* how much of the 4K can fit on screen */
extern int gfs2_struct_type;
extern int identify;
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index e8b71dc5..7f27109a 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -51,11 +51,10 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size)
jindex_block = masterblock("jindex");
/* read in the block */
jindex_bh = bread(&sbd, jindex_block);
- /* get the dinode data from it. */
- gfs2_dinode_in(&di, jindex_bh->b_data);
+ di = (struct gfs2_dinode *)jindex_bh->b_data;
if (!sbd.gfs1)
- do_dinode_extended(&di, jindex_bh->b_data); /* parse dir. */
+ do_dinode_extended(jindex_bh->b_data); /* parse dir. */
if (sbd.gfs1) {
struct gfs2_inode *jiinode;
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index e9401e4a..664c92d6 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -272,7 +272,7 @@ static int init_per_node_lookup(void)
return 1;
}
- do_dinode_extended(&per_node_di->i_di, per_node_di->i_bh->b_data);
+ do_dinode_extended(per_node_di->i_bh->b_data);
inode_put(&per_node_di);
for (i = 0; i < indirect_blocks; i++) {
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index 19d060f5..594db181 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -725,6 +725,7 @@ extern void gfs2_log_header_print(const struct gfs2_log_header *lh);
extern void lgfs2_inum_print(void *nop);
extern void lgfs2_meta_header_print(void *mhp);
extern void lgfs2_sb_print(void *sbp);
+extern void lgfs2_dinode_print(void *dip);
extern void lgfs2_log_descriptor_print(void *ldp);
extern void lgfs2_quota_print(void *qp);
extern void lgfs2_quota_change_print(void *qcp);
diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c
index 5e69ee98..a7f87d7a 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -384,6 +384,34 @@ void gfs2_dinode_print(const struct gfs2_dinode *di)
pv(di, di_eattr, "%"PRIu64, "0x%"PRIx64);
}
+void lgfs2_dinode_print(void *dip)
+{
+ struct gfs2_dinode *di = dip;
+
+ lgfs2_meta_header_print(&di->di_header);
+ lgfs2_inum_print(&di->di_num);
+
+ print_it(" di_mode", "0%"PRIo32, NULL, be32_to_cpu(di->di_mode));
+ printbe32(di, di_uid);
+ printbe32(di, di_gid);
+ printbe32(di, di_nlink);
+ printbe32(di, di_size);
+ printbe64(di, di_blocks);
+ printbe64(di, di_atime);
+ printbe64(di, di_mtime);
+ printbe64(di, di_ctime);
+ printbe32(di, di_major);
+ printbe32(di, di_minor);
+ printbe64(di, di_goal_meta);
+ printbe64(di, di_goal_data);
+ print_it(" di_flags", "0x%.8"PRIX32, NULL, be32_to_cpu(di->di_flags));
+ printbe32(di, di_payload_format);
+ printbe16(di, di_height);
+ printbe16(di, di_depth);
+ printbe32(di, di_entries);
+ printbe64(di, di_eattr);
+}
+
void gfs2_dirent_in(struct gfs2_dirent *de, char *buf)
{
struct gfs2_dirent *str = (struct gfs2_dirent *)buf;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
- 1
- 0