[gfs2-utils] 27/27: fsck.gfs2: Fix remaining endianness sparse
warnings
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 6206a0b75fe4af75522d2f137ef46a454f330e34
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Mon Jun 14 17:58:44 2021 +0100
fsck.gfs2: Fix remaining endianness sparse warnings
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/fsck/afterpass1_common.c | 2 +-
gfs2/fsck/afterpass1_common.h | 2 +-
gfs2/fsck/fs_recovery.c | 16 ++++------
gfs2/fsck/initialize.c | 72 ++++++++++++++++---------------------------
gfs2/fsck/lost_n_found.c | 2 +-
gfs2/fsck/metawalk.c | 35 +++++++++++----------
gfs2/fsck/metawalk.h | 8 ++---
gfs2/fsck/pass1.c | 6 ++--
gfs2/fsck/pass1b.c | 12 ++++----
gfs2/fsck/pass2.c | 19 ++++++------
gfs2/fsck/util.c | 4 +--
gfs2/fsck/util.h | 2 +-
gfs2/libgfs2/gfs1.c | 4 +--
gfs2/libgfs2/libgfs2.h | 2 +-
14 files changed, 82 insertions(+), 104 deletions(-)
diff --git a/gfs2/fsck/afterpass1_common.c b/gfs2/fsck/afterpass1_common.c
index 9b849316..6e5fbe0c 100644
--- a/gfs2/fsck/afterpass1_common.c
+++ b/gfs2/fsck/afterpass1_common.c
@@ -279,7 +279,7 @@ int delete_eattr_entry(struct gfs2_inode *ip, struct gfs2_buffer_head *leaf_bh,
return 0;
}
-int delete_eattr_extentry(struct gfs2_inode *ip, int i, uint64_t *ea_data_ptr,
+int delete_eattr_extentry(struct gfs2_inode *ip, int i, __be64 *ea_data_ptr,
struct gfs2_buffer_head *leaf_bh, uint32_t tot_ealen,
struct gfs2_ea_header *ea_hdr,
struct gfs2_ea_header *ea_hdr_prev, void *private)
diff --git a/gfs2/fsck/afterpass1_common.h b/gfs2/fsck/afterpass1_common.h
index e12ed96e..51cb2140 100644
--- a/gfs2/fsck/afterpass1_common.h
+++ b/gfs2/fsck/afterpass1_common.h
@@ -20,7 +20,7 @@ extern int delete_eattr_entry(struct gfs2_inode *ip,
struct gfs2_ea_header *ea_hdr_prev,
void *private);
extern int delete_eattr_extentry(struct gfs2_inode *ip, int i,
- uint64_t *ea_data_ptr,
+ __be64 *ea_data_ptr,
struct gfs2_buffer_head *leaf_bh,
uint32_t tot_ealen,
struct gfs2_ea_header *ea_hdr,
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index b62f7a65..12b8d704 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -138,7 +138,7 @@ static int buf_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
gfs2_replay_incr_blk(ip, &start);
for (; blks; gfs2_replay_incr_blk(ip, &start), blks--) {
- uint32_t check_magic;
+ struct gfs2_meta_header *mhp;
sd_found_metablocks++;
@@ -162,10 +162,8 @@ static int buf_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
}
memcpy(bh_ip->b_data, bh_log->b_data, sdp->sd_bsize);
- check_magic = ((struct gfs2_meta_header *)
- (bh_ip->b_data))->mh_magic;
- check_magic = be32_to_cpu(check_magic);
- if (check_magic != GFS2_MAGIC) {
+ mhp = (struct gfs2_meta_header *)bh_ip->b_data;
+ if (be32_to_cpu(mhp->mh_magic) != GFS2_MAGIC) {
log_err(_("Journal corruption detected at block #"
"%lld (0x%llx) for journal+0x%x.\n"),
(unsigned long long)blkno, (unsigned long long)blkno,
@@ -322,15 +320,13 @@ static int foreach_descriptor(struct gfs2_inode *ip, unsigned int start,
offset &= ~(sizeof(__be64) - 1);
while (start != end) {
- uint32_t check_magic;
+ struct gfs2_meta_header *mhp;
error = gfs2_replay_read_block(ip, start, &bh);
if (error)
return error;
- check_magic = ((struct gfs2_meta_header *)
- (bh->b_data))->mh_magic;
- check_magic = be32_to_cpu(check_magic);
- if (check_magic != GFS2_MAGIC) {
+ mhp = (struct gfs2_meta_header *)bh->b_data;
+ if (be32_to_cpu(mhp->mh_magic) != GFS2_MAGIC) {
bmodified(bh);
brelse(bh);
return -EIO;
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 4bc7eef6..9ba4bc89 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -788,7 +788,7 @@ static int fetch_rgrps(struct gfs2_sbd *sdp)
*/
static int init_system_inodes(struct gfs2_sbd *sdp)
{
- uint64_t inumbuf = 0;
+ __be64 inumbuf = 0;
char *buf;
int err;
@@ -1143,8 +1143,6 @@ static int find_rgs_for_bsize(struct gfs2_sbd *sdp, uint64_t startblock,
uint64_t blk, max_rg_size, rb_addr;
struct gfs2_buffer_head *bh, *rb_bh;
uint32_t bsize, bsize2;
- uint32_t chk;
- char *p;
int found_rg;
sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
@@ -1154,14 +1152,13 @@ static int find_rgs_for_bsize(struct gfs2_sbd *sdp, uint64_t startblock,
for (blk = startblock; blk < startblock + max_rg_size; blk++) {
bh = bread(sdp, blk);
found_rg = 0;
- for (bsize = 0; bsize < GFS2_DEFAULT_BSIZE;
- bsize += GFS2_BASIC_BLOCK) {
- p = bh->b_data + bsize;
- chk = ((struct gfs2_meta_header *)p)->mh_magic;
- if (be32_to_cpu(chk) != GFS2_MAGIC)
+ for (bsize = 0; bsize < GFS2_DEFAULT_BSIZE; bsize += GFS2_BASIC_BLOCK) {
+ struct gfs2_meta_header *mhp;
+
+ mhp = (struct gfs2_meta_header *)(bh->b_data + bsize);
+ if (be32_to_cpu(mhp->mh_magic) != GFS2_MAGIC)
continue;
- chk = ((struct gfs2_meta_header *)p)->mh_type;
- if (be32_to_cpu(chk) == GFS2_METATYPE_RG) {
+ if (be32_to_cpu(mhp->mh_type) == GFS2_METATYPE_RG) {
found_rg = 1;
break;
}
@@ -1382,23 +1379,6 @@ static int fill_super_block(struct gfs2_sbd *sdp)
return 0;
}
-static void gfs_log_header_out(struct gfs_log_header *head, char *buf)
-{
- struct gfs_log_header *str = (struct gfs_log_header *) buf;
-
- str->lh_header.mh_magic = cpu_to_be32(head->lh_header.mh_magic);
- str->lh_header.mh_type = cpu_to_be32(head->lh_header.mh_type);
- str->lh_header.mh_format = cpu_to_be32(head->lh_header.mh_format);
- str->lh_header.__pad0 = cpu_to_be32(head->lh_header.__pad0);
-
- str->lh_flags = cpu_to_be32(head->lh_flags);
- str->lh_pad = cpu_to_be32(head->lh_pad);
- str->lh_first = cpu_to_be64(head->lh_first);
- str->lh_sequence = cpu_to_be64(head->lh_sequence);
- str->lh_tail = cpu_to_be64(head->lh_tail);
- str->lh_last_dump = cpu_to_be64(head->lh_last_dump);
-}
-
/*
* reconstruct_single_journal - write a fresh GFS1 journal
* @sdp: superblock
@@ -1413,31 +1393,33 @@ static void gfs_log_header_out(struct gfs_log_header *head, char *buf)
static int reconstruct_single_journal(struct gfs2_sbd *sdp, int jnum,
uint32_t ji_nsegment)
{
- struct gfs_log_header lh;
- uint32_t seg, sequence;
+ uint64_t first = sdp->md.journal[jnum]->i_num.in_addr;
struct gfs2_buffer_head *bh;
+ uint64_t sequence;
srandom(time(NULL));
sequence = ji_nsegment / (RAND_MAX + 1.0) * random();
log_info(_("Clearing journal %d\n"), jnum);
- for (seg = 0; seg < ji_nsegment; seg++){
- memset(&lh, 0, sizeof(struct gfs_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_header.__pad0 = 0x101674; /* mh_generation */
- lh.lh_flags = GFS2_LOG_HEAD_UNMOUNT;
- lh.lh_first = sdp->md.journal[jnum]->i_num.in_addr + (seg * sdp->sd_seg_size);
- lh.lh_sequence = sequence;
-
- 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));
+ for (int seg = 0; seg < ji_nsegment; seg++, first += sdp->sd_seg_size){
+ struct gfs_log_header *lh;
+ char *p;
+
+ bh = bget(sdp, first); /* Zeroes the block */
+ lh = (struct gfs_log_header *)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_header.__pad0 = cpu_to_be64(0x101674); /* mh_generation */
+ lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT);
+ lh->lh_first = cpu_to_be64(first);
+ lh->lh_sequence = cpu_to_be64(sequence);
+
+ p = bh->b_data + GFS2_BASIC_BLOCK - sizeof(struct gfs_log_header);
+ memcpy(p, bh->b_data, sizeof(struct gfs_log_header));
+ bmodified(bh);
brelse(bh);
if (++sequence == ji_nsegment)
diff --git a/gfs2/fsck/lost_n_found.c b/gfs2/fsck/lost_n_found.c
index a9ff85bd..338f2a0a 100644
--- a/gfs2/fsck/lost_n_found.c
+++ b/gfs2/fsck/lost_n_found.c
@@ -172,7 +172,7 @@ void make_sure_lf_exists(struct gfs2_inode *ip)
*/
int add_inode_to_lf(struct gfs2_inode *ip){
char tmp_name[256];
- __be32 inode_type;
+ unsigned inode_type;
struct gfs2_sbd *sdp = ip->i_sbd;
struct lgfs2_inum no;
int err = 0;
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index edeaed88..4f36fe63 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -663,7 +663,7 @@ static int u64cmp(const void *p1, const void *p2)
return 0;
}
-static void dir_leaf_reada(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize)
+static void dir_leaf_reada(struct gfs2_inode *ip, __be64 *tbl, unsigned hsize)
{
uint64_t *t = alloca(hsize * sizeof(uint64_t));
uint64_t leaf_no;
@@ -692,7 +692,7 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
int lindex;
struct gfs2_sbd *sdp = ip->i_sbd;
int ref_count, orig_ref_count, orig_di_depth, orig_di_height;
- uint64_t *tbl;
+ __be64 *tbl;
int chained_leaf, tbl_valid;
tbl = get_dir_hash(ip);
@@ -846,7 +846,7 @@ static int check_eattr_entries(struct gfs2_inode *ip,
struct metawalk_fxns *pass)
{
struct gfs2_ea_header *ea_hdr, *ea_hdr_prev = NULL;
- uint64_t *ea_data_ptr = NULL;
+ __be64 *ea_data_ptr = NULL;
int i;
int error = 0, err;
uint32_t offset = (uint32_t)sizeof(struct gfs2_meta_header);
@@ -873,7 +873,7 @@ static int check_eattr_entries(struct gfs2_inode *ip,
uint32_t tot_ealen = 0;
struct gfs2_sbd *sdp = ip->i_sbd;
- ea_data_ptr = ((uint64_t *)((char *)ea_hdr +
+ ea_data_ptr = ((__be64 *)((char *)ea_hdr +
sizeof(struct gfs2_ea_header) +
((ea_hdr->ea_name_len + 7) & ~7)));
@@ -962,7 +962,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect,
struct metawalk_fxns *pass)
{
int error = 0, err;
- uint64_t *ea_leaf_ptr, *end;
+ __be64 *ea_leaf_ptr, *end;
uint64_t block;
struct gfs2_sbd *sdp = ip->i_sbd;
int first_ea_is_bad = 0;
@@ -970,7 +970,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect,
uint64_t offset = ip->i_sbd->gfs1 ? sizeof(struct gfs_indirect) : sizeof(struct gfs2_meta_header);
int leaf_pointers = 0, leaf_pointer_errors = 0;
- ea_leaf_ptr = (uint64_t *)(indirect_buf->b_data + offset);
+ ea_leaf_ptr = (__be64 *)(indirect_buf->b_data + offset);
end = ea_leaf_ptr + ((sdp->sd_bsize - offset) / 8);
while (*ea_leaf_ptr && (ea_leaf_ptr < end)){
@@ -1112,11 +1112,12 @@ static void file_ra(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
int head_size, int maxptrs, int h)
{
struct gfs2_sbd *sdp = ip->i_sbd;
- uint64_t *p, sblock = 0, block;
+ uint64_t sblock = 0, block;
int extlen = 0;
+ __be64 *p;
if (h + 2 == ip->i_height) {
- p = (uint64_t *)(bh->b_data + head_size);
+ p = (__be64 *)(bh->b_data + head_size);
if (*p && *(p + 1)) {
sblock = be64_to_cpu(*p);
p++;
@@ -1132,8 +1133,8 @@ 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->sd_bsize); p++) {
+ for (p = (__be64 *)(bh->b_data + head_size);
+ p < (__be64 *)(bh->b_data + sdp->sd_bsize); p++) {
if (*p) {
if (!sblock) {
sblock = be64_to_cpu(*p);
@@ -1225,9 +1226,9 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp,
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};
+ struct iptr iptr = { .ipt_ip = ip, NULL, 0};
int h, head_size, iblk_type;
- uint64_t *undoptr;
+ __be64 *undoptr;
int maxptrs;
int error;
@@ -1308,7 +1309,7 @@ error_undo: /* undo what we've done so far for this block */
log_info(_("Undoing the work we did before the error on block %"PRIu64" (0x%"PRIx64").\n"),
iptr.ipt_bh->b_blocknr, iptr.ipt_bh->b_blocknr);
- for (undoptr = (uint64_t *)(iptr_buf(iptr) + head_size);
+ for (undoptr = (__be64 *)(iptr_buf(iptr) + head_size);
undoptr < iptr_ptr(iptr) && undoptr < iptr_endptr(iptr);
undoptr++) {
uint64_t block = be64_to_cpu(*undoptr);
@@ -1398,8 +1399,8 @@ 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->sd_bsize);
+ __be64 *ptr_start = (__be64 *)(bh->b_data + hdr_size(bh, height));
+ __be64 *ptr_end = (__be64 *)(bh->b_data + ip->i_sbd->sd_bsize);
__be64 *ptr;
uint64_t metablock = bh->b_blocknr;
@@ -1464,8 +1465,8 @@ static int undo_check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass,
struct gfs2_buffer_head *bh, unsigned int height,
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->sd_bsize);
+ __be64 *ptr_start = (__be64 *)(bh->b_data + hdr_size(bh, height));
+ __be64 *ptr_end = (__be64 *)(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 a1038854..6e4bcad6 100644
--- a/gfs2/fsck/metawalk.h
+++ b/gfs2/fsck/metawalk.h
@@ -48,9 +48,9 @@ struct iptr {
unsigned ipt_off;
};
-#define iptr_ptr(i) ((uint64_t *)(i.ipt_bh->b_data + i.ipt_off))
+#define iptr_ptr(i) ((__be64 *)(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->sd_bsize))
+#define iptr_endptr(i) ((__be64 *)(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
@@ -114,7 +114,7 @@ struct metawalk_fxns {
struct gfs2_ea_header *ea_hdr_prev,
void *private);
int (*check_eattr_extentry) (struct gfs2_inode *ip, int i,
- uint64_t *ea_data_ptr,
+ __be64 *ea_data_ptr,
struct gfs2_buffer_head *leaf_bh,
uint32_t tot_ealen,
struct gfs2_ea_header *ea_hdr,
@@ -123,7 +123,7 @@ struct metawalk_fxns {
int (*finish_eattr_indir) (struct gfs2_inode *ip, int leaf_pointers,
int leaf_pointer_errors, void *private);
void (*big_file_msg) (struct gfs2_inode *ip, uint64_t blks_checked);
- int (*check_hash_tbl) (struct gfs2_inode *ip, uint64_t *tbl,
+ int (*check_hash_tbl) (struct gfs2_inode *ip, __be64 *tbl,
unsigned hsize, void *private);
int (*repair_leaf) (struct gfs2_inode *ip, uint64_t *leaf_no,
int lindex, int ref_count, const char *msg);
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 465cbceb..b283c752 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -60,7 +60,7 @@ static int check_eattr_entries(struct gfs2_inode *ip,
struct gfs2_ea_header *ea_hdr_prev,
void *private);
static int check_extended_leaf_eattr(struct gfs2_inode *ip, int i,
- uint64_t *data_ptr,
+ __be64 *data_ptr,
struct gfs2_buffer_head *leaf_bh,
uint32_t tot_ealen,
struct gfs2_ea_header *ea_hdr,
@@ -817,7 +817,7 @@ static int check_ealeaf_block(struct gfs2_inode *ip, uint64_t block, int btype,
* Returns: 0 if correct[able], -1 if removal is needed
*/
static int check_extended_leaf_eattr(struct gfs2_inode *ip, int i,
- uint64_t *data_ptr,
+ __be64 *data_ptr,
struct gfs2_buffer_head *leaf_bh,
uint32_t tot_ealen,
struct gfs2_ea_header *ea_hdr,
@@ -1705,7 +1705,7 @@ static int pass1_process_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd, uin
for (i = 0; i < n; i++) {
int is_inode;
- uint32_t check_magic;
+ __be32 check_magic;
block = ibuf[i];
diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c
index dd7653b9..ad997b56 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -43,7 +43,7 @@ struct meta_blk_ref {
static int clone_data(struct gfs2_inode *ip, uint64_t metablock,
uint64_t block, void *private,
- struct gfs2_buffer_head *bh, uint64_t *ptr);
+ struct gfs2_buffer_head *bh, __be64 *ptr);
static void log_inode_reference(struct duptree *dt, osi_list_t *tmp, int inval)
{
@@ -85,7 +85,7 @@ static int findref_data(struct gfs2_inode *ip, uint64_t metablock,
if (block == mbr->block) {
mbr->metablock = bh->b_blocknr;
- mbr->off = (ptr - (uint64_t *)bh->b_data);
+ mbr->off = (ptr - (__be64 *)bh->b_data);
log_debug("Duplicate data reference located on metadata "
"block 0x%llx, offset 0x%x\n",
(unsigned long long)mbr->metablock, mbr->off);
@@ -105,7 +105,7 @@ static void clone_data_block(struct gfs2_sbd *sdp, struct duptree *dt,
struct clone_target clone = {.dup_block = dt->block,};
struct gfs2_inode *ip;
struct gfs2_buffer_head *bh;
- uint64_t *ptr;
+ __be64 *ptr;
if (!(query(_("Okay to clone data block %lld (0x%llx) for inode "
"%lld (0x%llx)? (y/n) "),
@@ -125,7 +125,7 @@ static void clone_data_block(struct gfs2_sbd *sdp, struct duptree *dt,
bh = bread(sdp, metaref.metablock);
else
bh = ip->i_bh;
- ptr = (uint64_t *)bh->b_data + metaref.off;
+ ptr = (__be64 *)bh->b_data + metaref.off;
clone_data(ip, 0, dt->block, &clone, bh, ptr);
if (metaref.metablock != id->block_no)
brelse(bh);
@@ -644,7 +644,7 @@ static int handle_dup_blk(struct gfs2_sbd *sdp, struct duptree *dt)
osi_list_t *tmp;
struct dup_handler dh = {0};
struct gfs2_buffer_head *bh;
- uint32_t cmagic, ctype;
+ __be32 cmagic, ctype;
enum dup_ref_type acceptable_ref;
uint64_t dup_blk;
@@ -836,7 +836,7 @@ static int check_eattr_entry_refs(struct gfs2_inode *ip,
}
static int check_eattr_extentry_refs(struct gfs2_inode *ip, int i,
- uint64_t *ea_data_ptr,
+ __be64 *ea_data_ptr,
struct gfs2_buffer_head *leaf_bh,
uint32_t tot_ealen,
struct gfs2_ea_header *ea_hdr,
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 6592edaf..67833491 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -300,7 +300,7 @@ static int wrong_leaf(struct gfs2_inode *ip, struct lgfs2_inum *entry,
struct gfs2_buffer_head *dest_lbh;
uint64_t planned_leaf, real_leaf;
int li, dest_ref, error;
- uint64_t *tbl;
+ __be64 *tbl;
int di_depth;
log_err(_("Directory entry '%s' at block %"PRIu64" (0x%"PRIx64") is on the wrong leaf block.\n"),
@@ -938,12 +938,11 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
struct gfs2_dirent *dent;
int count, i;
int factor = 0, pad_size;
- uint64_t *cpyptr;
- char *padbuf;
+ __be64 *padbuf, *cpyptr;
int divisor = num_copies;
int end_lindex = start_lindex + num_copies;
- padbuf = malloc(num_copies * sizeof(uint64_t));
+ padbuf = calloc(num_copies, sizeof(__be64));
/* calculate the depth needed for the new leaf */
while (divisor > 1) {
factor++;
@@ -992,7 +991,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
brelse(nbh);
/* pad the hash table with the new leaf block */
- cpyptr = (uint64_t *)padbuf;
+ cpyptr = padbuf;
for (i = start_lindex; i < end_lindex; i++) {
*cpyptr = cpu_to_be64(*bn);
cpyptr++;
@@ -1024,7 +1023,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
* @lindex: index location within the hash table to pad
* @len: number of pointers to be padded
*/
-static void pad_with_leafblks(struct gfs2_inode *ip, uint64_t *tbl,
+static void pad_with_leafblks(struct gfs2_inode *ip, __be64 *tbl,
int lindex, int len)
{
int new_len, i;
@@ -1075,7 +1074,7 @@ static void pad_with_leafblks(struct gfs2_inode *ip, uint64_t *tbl,
* directory entries to lost+found so we don't overwrite the good leaf. Then
* we need to pad the gap we leave.
*/
-static int lost_leaf(struct gfs2_inode *ip, uint64_t *tbl, uint64_t leafno,
+static int lost_leaf(struct gfs2_inode *ip, __be64 *tbl, uint64_t leafno,
int ref_count, int lindex, struct gfs2_buffer_head *bh)
{
char *filename;
@@ -1292,7 +1291,7 @@ static struct metawalk_fxns leafck_fxns = {
*
* Returns: 0 - no changes made, or X if changes were made
*/
-static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize,
+static int fix_hashtable(struct gfs2_inode *ip, __be64 *tbl, unsigned hsize,
uint64_t leafblk, int lindex, uint32_t proper_start,
int len, int *proper_len, int factor)
{
@@ -1471,7 +1470,7 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize,
}
/* check_hash_tbl_dups - check for the same leaf in multiple places */
-static int check_hash_tbl_dups(struct gfs2_inode *ip, uint64_t *tbl,
+static int check_hash_tbl_dups(struct gfs2_inode *ip, __be64 *tbl,
unsigned hsize, int lindex, int len)
{
int l, len2;
@@ -1590,7 +1589,7 @@ static int check_hash_tbl_dups(struct gfs2_inode *ip, uint64_t *tbl,
* we may need to reference leaf blocks to fix it, which means we need
* to check and/or fix a leaf block along the way.
*/
-static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
+static int check_hash_tbl(struct gfs2_inode *ip, __be64 *tbl,
unsigned hsize, void *private)
{
int error = 0;
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index 762266df..7ea2dfb8 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -575,11 +575,11 @@ uint64_t find_free_blk(struct gfs2_sbd *sdp)
return 0;
}
-uint64_t *get_dir_hash(struct gfs2_inode *ip)
+__be64 *get_dir_hash(struct gfs2_inode *ip)
{
unsigned hsize = (1 << ip->i_depth) * sizeof(uint64_t);
int ret;
- uint64_t *tbl = malloc(hsize);
+ __be64 *tbl = malloc(hsize);
if (tbl == NULL)
return NULL;
diff --git a/gfs2/fsck/util.h b/gfs2/fsck/util.h
index d56bb24b..88b6aa35 100644
--- a/gfs2/fsck/util.h
+++ b/gfs2/fsck/util.h
@@ -128,7 +128,7 @@ extern char generic_interrupt(const char *caller, const char *where,
const char *answers);
extern char gfs2_getch(void);
extern uint64_t find_free_blk(struct gfs2_sbd *sdp);
-extern uint64_t *get_dir_hash(struct gfs2_inode *ip);
+extern __be64 *get_dir_hash(struct gfs2_inode *ip);
extern void delete_all_dups(struct gfs2_inode *ip);
extern void print_pass_duration(const char *name, struct timeval *start);
diff --git a/gfs2/libgfs2/gfs1.c b/gfs2/libgfs2/gfs1.c
index 272f5572..850d7217 100644
--- a/gfs2/libgfs2/gfs1.c
+++ b/gfs2/libgfs2/gfs1.c
@@ -163,7 +163,7 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
brelse(bh);
}
-int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
+int gfs1_writei(struct gfs2_inode *ip, void *buf, uint64_t offset,
unsigned int size)
{
struct gfs2_sbd *sdp = ip->i_sbd;
@@ -222,7 +222,7 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
memcpy(bh->b_data, &mh, sizeof(mh));
}
- memcpy(bh->b_data + offset, buf + copied, amount);
+ memcpy(bh->b_data + offset, (char *)buf + copied, amount);
bmodified(bh);
if (bh != ip->i_bh)
brelse(bh);
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index c8ec05aa..41f83b94 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -732,7 +732,7 @@ extern void gfs1_lookup_block(struct gfs2_inode *ip,
int create, int *new, uint64_t *block);
extern void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
uint64_t *dblock, uint32_t *extlen, int prealloc);
-extern int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
+extern int gfs1_writei(struct gfs2_inode *ip, void *buf, uint64_t offset,
unsigned int size);
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);
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
[gfs2-utils] 26/27: gfs2_edit: Fix remaining endianness sparse
warnings
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 e2d50e6044d9d75b1bad31000ff4a43bfffea585
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Fri Jun 11 18:25:38 2021 +0100
gfs2_edit: Fix remaining endianness sparse warnings
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/edit/extended.c | 7 +--
gfs2/edit/gfs2hex.c | 11 +++--
gfs2/edit/hexedit.c | 26 ++++++-----
gfs2/edit/hexedit.h | 2 -
gfs2/edit/journal.c | 39 ++++++++--------
gfs2/edit/savemeta.c | 125 +++++++++++++++++++++++++++------------------------
6 files changed, 110 insertions(+), 100 deletions(-)
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index d6e4624a..c2865829 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -61,7 +61,7 @@ static int _do_indirect_extended(char *diebuf, struct iinfo *iinf, int hgt)
}
headoff = sbd.gfs1 ? sizeof(struct gfs_indirect) : sizeof(struct gfs2_meta_header);
for (x = headoff, y = 0; x < sbd.sd_bsize; x += sizeof(uint64_t), y++) {
- p = be64_to_cpu(*(uint64_t *)(diebuf + x));
+ p = be64_to_cpu(*(__be64 *)(diebuf + x));
if (p) {
iinf->ii[i_blocks].block = p;
iinf->ii[i_blocks].mp.mp_list[hgt] = i_blocks;
@@ -228,7 +228,7 @@ static int display_indirect(struct iinfo *ind, int indblocks, int level,
return 0;
}
-static void print_inode_type(__be16 de_type)
+static void print_inode_type(uint16_t de_type)
{
if (sbd.gfs1) {
switch(de_type) {
@@ -558,7 +558,8 @@ static int parse_rindex(struct gfs2_inode *dip, int print_rindex)
static int print_inum(struct gfs2_inode *dii)
{
- uint64_t inum, inodenum;
+ uint64_t inodenum;
+ __be64 inum;
int rc;
rc = gfs2_readi(dii, (void *)&inum, 0, sizeof(inum));
diff --git a/gfs2/edit/gfs2hex.c b/gfs2/edit/gfs2hex.c
index 95572fef..219a20ea 100644
--- a/gfs2/edit/gfs2hex.c
+++ b/gfs2/edit/gfs2hex.c
@@ -49,9 +49,7 @@ int start_row[DMODES], end_row[DMODES], lines_per_row[DMODES];
int gfs2_struct_type;
unsigned int offset;
struct indirect_info masterdir;
-struct gfs2_inum gfs1_quota_di;
int print_entry_ndx;
-struct gfs2_inum gfs1_license_di;
int screen_chunk_size = 512;
uint64_t temp_blk;
int color_scheme = 0;
@@ -244,12 +242,13 @@ static int indirect_dirent(struct indirect_info *indir, void *ptr, int d)
void do_dinode_extended(char *buf)
{
struct gfs2_dinode *dip = (void *)buf;
+ struct gfs_dinode *dip1 = (void *)buf;
unsigned int x, y, ptroff = 0;
uint64_t p, last;
int isdir = 0;
if (S_ISDIR(be32_to_cpu(dip->di_mode)) ||
- (sbd.gfs1 && be16_to_cpu(dip->__pad1) == GFS_FILE_DIR))
+ (sbd.gfs1 && be16_to_cpu(dip1->di_type) == GFS_FILE_DIR))
isdir = 1;
indirect_blocks = 0;
@@ -258,7 +257,7 @@ void do_dinode_extended(char *buf)
/* Indirect pointers */
for (x = sizeof(struct gfs2_dinode); x < sbd.sd_bsize;
x += sizeof(uint64_t)) {
- p = be64_to_cpu(*(uint64_t *)(buf + x));
+ p = be64_to_cpu(*(__be64 *)(buf + x));
if (p) {
indirect->ii[indirect_blocks].block = p;
indirect->ii[indirect_blocks].mp.mp_list[0] =
@@ -289,12 +288,12 @@ void do_dinode_extended(char *buf)
dip->di_height == 0) {
/* Leaf Pointers: */
- last = be64_to_cpu(*(uint64_t *)(buf + sizeof(struct gfs2_dinode)));
+ last = be64_to_cpu(*(__be64 *)(buf + sizeof(struct gfs2_dinode)));
for (x = sizeof(struct gfs2_dinode), y = 0;
y < (1 << be16_to_cpu(dip->di_depth));
x += sizeof(uint64_t), y++) {
- p = be64_to_cpu(*(uint64_t *)(buf + x));
+ p = be64_to_cpu(*(__be64 *)(buf + x));
if (p != last || ((y + 1) * sizeof(uint64_t) == be64_to_cpu(dip->di_size))) {
struct gfs2_buffer_head *tmp_bh;
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index fd7388ce..302f0843 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -40,6 +40,8 @@ static struct gfs2_buffer_head *bh;
static int pgnum;
static long int gziplevel = 9;
static int termcols;
+static struct lgfs2_inum gfs1_quota_di;
+static struct lgfs2_inum gfs1_license_di;
int details = 0;
char *device = NULL;
@@ -445,11 +447,11 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
if (sbd.gfs1) {
if (block == sbd.sd_rindex_di.in_addr)
print_gfs2("---------------- rindex file -------------------");
- else if (block == gfs1_quota_di.no_addr)
+ else if (block == gfs1_quota_di.in_addr)
print_gfs2("---------------- Quota file --------------------");
else if (block == sbd.sd_jindex_di.in_addr)
print_gfs2("--------------- Journal Index ------------------");
- else if (block == gfs1_license_di.no_addr)
+ else if (block == gfs1_license_di.in_addr)
print_gfs2("--------------- License file -------------------");
}
else {
@@ -501,13 +503,13 @@ static int hexdump(uint64_t startaddr, uint64_t len, int trunc_zeros,
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;
+ __be64 *ref;
int ptroffset = 0;
strcpy(edit_fmt,"%02x");
pointer = (unsigned char *)lpBuffer + offset;
ptr2 = (unsigned char *)lpBuffer + offset;
- ref = (uint64_t *)lpBuffer + offset;
+ ref = (__be64 *)lpBuffer + offset;
if (trunc_zeros) {
while (zeros_strt > lpBuffer && (*(zeros_strt - 1) == 0))
zeros_strt--;
@@ -810,11 +812,13 @@ static void set_rgrp_flags(int rgnum, uint32_t new_flags, int modify, int full)
/* ------------------------------------------------------------------------ */
int has_indirect_blocks(void)
{
+ struct gfs_dinode *d1 = (struct gfs_dinode *)di;
+
if (indirect_blocks || gfs2_struct_type == GFS2_METATYPE_SB ||
gfs2_struct_type == GFS2_METATYPE_LF ||
(gfs2_struct_type == GFS2_METATYPE_DI &&
(S_ISDIR(be32_to_cpu(di->di_mode)) ||
- (sbd.gfs1 && be16_to_cpu(di->__pad1) == GFS_FILE_DIR))))
+ (sbd.gfs1 && be16_to_cpu(d1->di_type) == GFS_FILE_DIR))))
return TRUE;
return FALSE;
}
@@ -843,7 +847,7 @@ int block_is_inum_file(uint64_t blk)
int block_is_statfs_file(uint64_t blk)
{
- if (sbd.gfs1 && blk == gfs1_license_di.no_addr)
+ if (sbd.gfs1 && blk == gfs1_license_di.in_addr)
return TRUE;
if (!sbd.gfs1 && blk == masterblock("statfs"))
return TRUE;
@@ -852,7 +856,7 @@ int block_is_statfs_file(uint64_t blk)
int block_is_quota_file(uint64_t blk)
{
- if (sbd.gfs1 && blk == gfs1_quota_di.no_addr)
+ if (sbd.gfs1 && blk == gfs1_quota_di.in_addr)
return TRUE;
if (!sbd.gfs1 && blk == masterblock("quota"))
return TRUE;
@@ -1330,7 +1334,7 @@ uint64_t check_keywords(const char *kword)
blk = masterblock("inum");
else if (!strcmp(kword, "statfs")) {
if (sbd.gfs1)
- blk = gfs1_license_di.no_addr;
+ blk = gfs1_license_di.in_addr;
else
blk = masterblock("statfs");
}
@@ -1343,7 +1347,7 @@ uint64_t check_keywords(const char *kword)
blk = RGLIST_DUMMY_BLOCK;
} else if (!strcmp(kword, "quota")) {
if (sbd.gfs1)
- blk = gfs1_quota_di.no_addr;
+ blk = gfs1_quota_di.in_addr;
else
blk = masterblock("quota");
} else if (!strncmp(kword, "rg ", 3)) {
@@ -1548,7 +1552,7 @@ static void jump(void)
{
if (dmode == HEX_MODE) {
unsigned int col2;
- uint64_t *b;
+ __be64 *b;
const struct lgfs2_metadata *mtype = get_block_type(bh->b_data);
uint32_t block_type = 0;
@@ -1563,7 +1567,7 @@ static void jump(void)
temp_blk = bh->b_blocknr + pnum + 1;
} else if (edit_row[dmode] >= 0) {
col2 = edit_col[dmode] & 0x08;/* thus 0-7->0, 8-15->8 */
- b = (uint64_t *)&bh->b_data[edit_row[dmode]*16 +
+ b = (__be64 *)&bh->b_data[edit_row[dmode]*16 +
offset + col2];
temp_blk = be64_to_cpu(*b);
}
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index e48c5885..29f465a0 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -46,8 +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 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 int screen_chunk_size; /* how much of the 4K can fit on screen */
extern int gfs2_struct_type;
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index d7710c2b..ea32f9a2 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -36,7 +36,6 @@ 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.sd_bsize];
journal_num = atoi(journal + 7);
if (journal_num < 0)
@@ -56,17 +55,17 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size)
if (sbd.gfs1) {
struct gfs2_inode *jiinode;
+ struct gfs_jindex jidx;
jiinode = lgfs2_inode_get(&sbd, jindex_bh);
if (jiinode == NULL)
return 0;
- amtread = gfs2_readi(jiinode, (void *)&jbuf,
+ amtread = gfs2_readi(jiinode, &jidx,
journal_num * sizeof(struct gfs_jindex),
sizeof(struct gfs_jindex));
if (amtread) {
- struct gfs_jindex *ji = (struct gfs_jindex *)jbuf;
- jblock = be64_to_cpu(ji->ji_addr);
- *j_size = (uint64_t)be32_to_cpu(ji->ji_nsegment) * 0x10;
+ jblock = be64_to_cpu(jidx.ji_addr);
+ *j_size = (uint64_t)be32_to_cpu(jidx.ji_nsegment) * 0x10;
}
inode_put(&jiinode);
} else {
@@ -174,10 +173,10 @@ static int fsck_readi(struct gfs2_inode *ip, void *rbuf, uint64_t roffset,
* This function checks a log descriptor buffer to see if it contains
* references to a given traced block, or its rgrp bitmap block.
*/
-static int ld_is_pertinent(const uint64_t *b, const char *end, uint64_t tblk,
+static int ld_is_pertinent(const __be64 *b, const char *end, uint64_t tblk,
struct rgrp_tree *rgd, uint64_t bitblk)
{
- const uint64_t *blk = b;
+ const __be64 *blk = b;
if (!tblk)
return 1;
@@ -196,7 +195,7 @@ static int ld_is_pertinent(const uint64_t *b, const char *end, uint64_t tblk,
* print_ld_blks - print all blocks given in a log descriptor
* returns: the number of block numbers it printed
*/
-static int print_ld_blks(const uint64_t *b, const char *end, int start_line,
+static int print_ld_blks(const __be64 *b, const char *end, int start_line,
uint64_t tblk, uint64_t *tblk_off, uint64_t bitblk,
struct rgrp_tree *rgd, uint64_t abs_block, int prnt,
uint64_t *bblk_off, int is_meta_ld)
@@ -223,13 +222,12 @@ static int print_ld_blks(const uint64_t *b, const char *end, int start_line,
if (is_meta_ld) {
j_bmap_bh = bread(&sbd, abs_block +
bcount);
- sprintf(str, "0x%llx %2s",
- (unsigned long long)be64_to_cpu(*b),
+ sprintf(str, "0x%"PRIx64" %2s",
+ be64_to_cpu(*b),
mtypes[lgfs2_get_block_type(j_bmap_bh->b_data)]);
brelse(j_bmap_bh);
} else {
- sprintf(str, "0x%llx",
- (unsigned long long)be64_to_cpu(*b));
+ sprintf(str, "0x%"PRIx64, be64_to_cpu(*b));
}
print_gfs2("%-18.18s ", str);
}
@@ -360,7 +358,7 @@ static int process_ld(uint64_t abs_block, uint64_t wrappt, uint64_t j_size,
uint64_t *tblk_off, uint64_t bitblk,
struct rgrp_tree *rgd, int *prnt, uint64_t *bblk_off)
{
- uint64_t *b;
+ __be64 *b;
struct gfs2_log_descriptor *ld = (void *)buf;
int ltndx, is_meta_ld = 0;
int ld_blocks = 0;
@@ -379,9 +377,9 @@ static int process_ld(uint64_t abs_block, uint64_t wrappt, uint64_t j_size,
"Quota", "Final Entry", "Unknown"}};
if (sbd.gfs1)
- b = (uint64_t *)(buf + sizeof(struct gfs_log_descriptor));
+ b = (__be64 *)(buf + sizeof(struct gfs_log_descriptor));
else
- b = (uint64_t *)(buf + sizeof(struct gfs2_log_descriptor));
+ b = (__be64 *)(buf + sizeof(struct gfs2_log_descriptor));
*prnt = ld_is_pertinent(b, (buf + sbd.sd_bsize), tblk, rgd, bitblk);
if (*prnt) {
@@ -418,7 +416,7 @@ static int meta_has_ref(uint64_t abs_block, int tblk)
const struct lgfs2_metadata *mtype;
struct gfs2_buffer_head *mbh;
int structlen = 0, has_ref = 0;
- uint64_t *b;
+ __be64 *b;
struct gfs2_dinode *dinode;
mbh = bread(&sbd, abs_block);
@@ -431,7 +429,7 @@ static int meta_has_ref(uint64_t abs_block, int tblk)
has_ref = 1;
}
}
- b = (uint64_t *)(mbh->b_data + structlen);
+ b = (__be64 *)(mbh->b_data + structlen);
while (!has_ref && mtype && (char *)b < mbh->b_data + sbd.sd_bsize) {
if (be64_to_cpu(*b) == tblk)
has_ref = 1;
@@ -452,10 +450,11 @@ static int meta_has_ref(uint64_t abs_block, int tblk)
static uint64_t get_ldref(uint64_t abs_ld, int offset_from_ld)
{
struct gfs2_buffer_head *jbh;
- uint64_t *b, refblk;
+ uint64_t refblk;
+ __be64 *b;
jbh = bread(&sbd, abs_ld);
- b = (uint64_t *)(jbh->b_data + sizeof(struct gfs2_log_descriptor));
+ b = (__be64 *)(jbh->b_data + sizeof(struct gfs2_log_descriptor));
b += offset_from_ld - 1;
refblk = be64_to_cpu(*b);
brelse(jbh);
@@ -618,7 +617,7 @@ void dump_journal(const char *journal, int tblk)
eol(0);
} else if ((ld_blocks > 0) &&
(sbd.gfs1 || block_type == GFS2_METATYPE_LB)) {
- uint64_t *b = (uint64_t *)(buf + (sbd.gfs1 ? 0 : sizeof(struct gfs2_meta_header)));
+ __be64 *b = (__be64 *)(buf + (sbd.gfs1 ? 0 : sizeof(struct gfs2_meta_header)));
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log descriptor"
" continuation block", abs_block,
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 473a2d03..5ccc46a8 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -32,17 +32,23 @@
/* Header for the savemeta output file */
struct savemeta_header {
#define SAVEMETA_MAGIC (0x01171970)
- uint32_t sh_magic;
+ __be32 sh_magic;
#define SAVEMETA_FORMAT (1)
- uint32_t sh_format; /* In case we want to change the layout */
- uint64_t sh_time; /* When savemeta was run */
- uint64_t sh_fs_bytes; /* Size of the fs */
+ __be32 sh_format; /* In case we want to change the layout */
+ __be64 sh_time; /* When savemeta was run */
+ __be64 sh_fs_bytes; /* Size of the fs */
uint8_t __reserved[104];
};
+struct savemeta {
+ time_t sm_time;
+ unsigned sm_format;
+ size_t sm_fs_bytes;
+};
+
struct saved_metablock {
- uint64_t blk;
- uint16_t siglen; /* significant data length */
+ __be64 blk;
+ __be16 siglen; /* significant data length */
/* This needs to be packed because old versions of gfs2_edit read and write the
individual fields separately, so the hole after siglen must be eradicated
before the struct reflects what's on disk. */
@@ -296,15 +302,17 @@ static int block_is_systemfile(uint64_t blk)
static size_t di_save_len(const char *buf, uint64_t owner)
{
const struct gfs2_dinode *dn;
+ const struct gfs_dinode *d1;
uint16_t di_height;
uint32_t di_mode;
int gfs1dir;
dn = (void *)buf;
+ d1 = (void *)buf;
di_mode = be32_to_cpu(dn->di_mode);
di_height = be16_to_cpu(dn->di_height);
/* __pad1 is di_type in gfs1 */
- gfs1dir = sbd.gfs1 && (be16_to_cpu(dn->__pad1) == GFS_FILE_DIR);
+ gfs1dir = sbd.gfs1 && (be16_to_cpu(d1->di_type) == GFS_FILE_DIR);
/* Do not save (user) data from the inode block unless they are
indirect pointers, dirents, symlinks or fs internal data */
@@ -697,8 +705,9 @@ static void save_ea_block(struct metafd *mfd, char *buf, uint64_t owner)
int e;
for (e = sizeof(struct gfs2_meta_header); e < sbd.sd_bsize; e += rec_len) {
- uint64_t blk, *b;
+ uint64_t blk;
int charoff, i;
+ __be64 *b;
ea = (void *)(buf + e);
/* ea_num_ptrs and ea_name_len are u8 so no endianness worries */
@@ -709,7 +718,7 @@ static void save_ea_block(struct metafd *mfd, char *buf, uint64_t owner)
sizeof(struct gfs2_ea_header) +
sizeof(uint64_t) - 1;
charoff /= sizeof(uint64_t);
- b = (uint64_t *)buf;
+ b = (__be64 *)buf;
b += charoff + i;
blk = be64_to_cpu(*b);
_buf = check_read_block(sbd.device_fd, blk, owner, NULL, NULL);
@@ -751,9 +760,9 @@ static void save_indirect_blocks(struct metafd *mfd, char *buf, uint64_t owner,
{
uint64_t old_block = 0, indir_block;
struct block_range *br = NULL;
- uint64_t *ptr;
+ __be64 *ptr;
- for (ptr = (uint64_t *)(buf + headsize);
+ for (ptr = (__be64 *)(buf + headsize);
(char *)ptr < (buf + sbd.sd_bsize); ptr++) {
if (!*ptr)
continue;
@@ -854,6 +863,7 @@ static void save_inode_data(struct metafd *mfd, char *ibuf, uint64_t iblk)
{
struct block_range_queue indq[GFS2_MAX_META_HEIGHT] = {{NULL}};
struct gfs2_dinode *dip = (struct gfs2_dinode *)ibuf;
+ struct gfs_dinode *dip1 = (struct gfs_dinode *)ibuf;
uint16_t height;
int is_exhash;
@@ -869,7 +879,7 @@ static void save_inode_data(struct metafd *mfd, char *ibuf, uint64_t iblk)
the hash table exists, and we have to save the directory data. */
is_exhash = (S_ISDIR(be32_to_cpu(dip->di_mode)) ||
- (sbd.gfs1 && be16_to_cpu(dip->__pad1) == GFS_FILE_DIR)) &&
+ (sbd.gfs1 && be16_to_cpu(dip1->di_type) == GFS_FILE_DIR)) &&
be32_to_cpu(dip->di_flags) & GFS2_DIF_EXHASH;
if (is_exhash)
height++;
@@ -1090,24 +1100,23 @@ static int save_header(struct metafd *mfd, uint64_t fsbytes)
return 0;
}
-static int parse_header(char *buf, struct savemeta_header *smh)
+static int parse_header(char *buf, struct savemeta *sm)
{
- struct savemeta_header *smh_be = (void *)buf;
+ struct savemeta_header *smh = (void *)buf;
- if (be32_to_cpu(smh_be->sh_magic) != SAVEMETA_MAGIC) {
+ if (be32_to_cpu(smh->sh_magic) != SAVEMETA_MAGIC) {
printf("No valid file header found. Falling back to old format...\n");
return 1;
}
- if (be32_to_cpu(smh_be->sh_format) > SAVEMETA_FORMAT) {
+ if (be32_to_cpu(smh->sh_format) > SAVEMETA_FORMAT) {
printf("This version of gfs2_edit is too old to restore this metadata format.\n");
return -1;
}
- smh->sh_magic = be32_to_cpu(smh_be->sh_magic);
- smh->sh_format = be32_to_cpu(smh_be->sh_format);
- smh->sh_time = be64_to_cpu(smh_be->sh_time);
- smh->sh_fs_bytes = be64_to_cpu(smh_be->sh_fs_bytes);
- printf("Metadata saved at %s", ctime((time_t *)&smh->sh_time)); /* ctime() adds \n */
- printf("File system size %.2fGB\n", smh->sh_fs_bytes / ((float)(1 << 30)));
+ sm->sm_format = be32_to_cpu(smh->sh_format);
+ sm->sm_time = be64_to_cpu(smh->sh_time);
+ sm->sm_fs_bytes = be64_to_cpu(smh->sh_fs_bytes);
+ printf("Metadata saved at %s", ctime(&sm->sm_time)); /* ctime() adds \n */
+ printf("File system size %.2fGB\n", sm->sm_fs_bytes / ((float)(1 << 30)));
return 0;
}
@@ -1206,34 +1215,35 @@ void savemeta(char *out_fn, int saveoption, int gziplevel)
exit(0);
}
-static char *restore_block(struct metafd *mfd, struct saved_metablock *svb)
+static char *restore_block(struct metafd *mfd, uint64_t *blk, uint16_t *siglen)
{
- struct saved_metablock *svb_be;
+ struct saved_metablock *svb;
const char *errstr;
char *buf = NULL;
- svb_be = (struct saved_metablock *)(restore_buf_next(mfd, sizeof(*svb)));
- if (svb_be == NULL)
+ svb = (struct saved_metablock *)(restore_buf_next(mfd, sizeof(*svb)));
+ if (svb == NULL)
goto nobuffer;
- svb->blk = be64_to_cpu(svb_be->blk);
- svb->siglen = be16_to_cpu(svb_be->siglen);
+ *blk = be64_to_cpu(svb->blk);
+ *siglen = be16_to_cpu(svb->siglen);
- if (sbd.fssize && svb->blk >= sbd.fssize) {
+ if (sbd.fssize && *blk >= sbd.fssize) {
fprintf(stderr, "Error: File system is too small to restore this metadata.\n");
- fprintf(stderr, "File system is %llu blocks. Restore block = %llu\n",
- (unsigned long long)sbd.fssize, (unsigned long long)svb->blk);
+ fprintf(stderr, "File system is %"PRIu64" blocks. Restore block = %"PRIu64"\n",
+ sbd.fssize, *blk);
return NULL;
}
- if (svb->siglen > sbd.sd_bsize) {
+ if (*siglen > sbd.sd_bsize) {
fprintf(stderr, "Bad record length: %u for block %"PRIu64" (0x%"PRIx64").\n",
- svb->siglen, svb->blk, svb->blk);
+ *siglen, *blk, *blk);
return NULL;
}
- buf = restore_buf_next(mfd, svb->siglen);
- if (buf != NULL)
+ buf = restore_buf_next(mfd, *siglen);
+ if (buf != NULL) {
return buf;
+ }
nobuffer:
if (mfd->eof)
return NULL;
@@ -1266,7 +1276,6 @@ static int restore_super(struct metafd *mfd, void *buf, int printonly)
static int restore_data(int fd, struct metafd *mfd, int printonly)
{
- struct saved_metablock savedata = {0};
uint64_t writes = 0;
char *buf;
@@ -1277,9 +1286,11 @@ static int restore_data(int fd, struct metafd *mfd, int printonly)
}
while (TRUE) {
+ uint16_t siglen = 0;
+ uint64_t blk = 0;
char *bp;
- bp = restore_block(mfd, &savedata);
+ bp = restore_block(mfd, &blk, &siglen);
if (bp == NULL && mfd->eof)
break;
if (bp == NULL) {
@@ -1287,23 +1298,21 @@ static int restore_data(int fd, struct metafd *mfd, int printonly)
return -1;
}
if (printonly) {
- if (printonly > 1 && printonly == savedata.blk) {
- display_block_type(bp, savedata.blk, TRUE);
+ if (printonly > 1 && printonly == blk) {
+ display_block_type(bp, blk, TRUE);
display_gfs2(bp);
break;
} else if (printonly == 1) {
- print_gfs2("%"PRId64" (l=0x%x): ", blks_saved, savedata.siglen);
- display_block_type(bp, savedata.blk, TRUE);
+ print_gfs2("%"PRId64" (l=0x%x): ", blks_saved, siglen);
+ display_block_type(bp, blk, TRUE);
}
} else {
- report_progress(savedata.blk, 0);
- memcpy(buf, bp, savedata.siglen);
- 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,
- (unsigned long long)savedata.blk);
+ report_progress(blk, 0);
+ memcpy(buf, bp, siglen);
+ memset(buf + siglen, 0, sbd.sd_bsize - siglen);
+ if (pwrite(fd, buf, sbd.sd_bsize, blk * sbd.sd_bsize) != sbd.sd_bsize) {
+ fprintf(stderr, "write error: %s from %s:%d: block %"PRIu64" (0x%"PRIx64")\n",
+ strerror(errno), __FUNCTION__, __LINE__, blk, blk);
free(buf);
return -1;
}
@@ -1326,8 +1335,9 @@ static void complain(const char *complaint)
"<dest file system>\n");
}
-static int restore_init(const char *path, struct metafd *mfd, struct savemeta_header *smh, int printonly)
+static int restore_init(const char *path, struct metafd *mfd, int printonly)
{
+ struct savemeta sm = {0};
struct gfs2_sb rsb;
uint16_t sb_siglen;
char *end;
@@ -1355,10 +1365,10 @@ static int restore_init(const char *path, struct metafd *mfd, struct savemeta_he
return -1;
}
bp = restore_buf;
- ret = parse_header(bp, smh);
+ ret = parse_header(bp, &sm);
if (ret == 0) {
- bp = restore_buf + sizeof(*smh);
- restore_off = sizeof(*smh);
+ bp = restore_buf + sizeof(struct savemeta_header);
+ restore_off = sizeof(struct savemeta_header);
} else if (ret == -1) {
return -1;
}
@@ -1381,10 +1391,10 @@ static int restore_init(const char *path, struct metafd *mfd, struct savemeta_he
if (ret != 0)
return ret;
- if (smh->sh_fs_bytes > 0) {
- sbd.fssize = smh->sh_fs_bytes / sbd.sd_bsize;
+ if (sm.sm_fs_bytes > 0) {
+ sbd.fssize = sm.sm_fs_bytes / sbd.sd_bsize;
printf("Saved file system size is %"PRIu64" blocks, %.2fGB\n",
- sbd.fssize, smh->sh_fs_bytes / ((float)(1 << 30)));
+ sbd.fssize, sm.sm_fs_bytes / ((float)(1 << 30)));
}
printf("Block size is %uB\n", sbd.sd_bsize);
printf("This is gfs%c metadata.\n", sbd.gfs1 ? '1': '2');
@@ -1403,7 +1413,6 @@ static int restore_init(const char *path, struct metafd *mfd, struct savemeta_he
void restoremeta(const char *in_fn, const char *out_device, uint64_t printonly)
{
- struct savemeta_header smh = {0};
struct metafd mfd = {0};
int error;
@@ -1422,7 +1431,7 @@ void restoremeta(const char *in_fn, const char *out_device, uint64_t printonly)
optional block no */
printonly = check_keywords(out_device);
- error = restore_init(in_fn, &mfd, &smh, printonly);
+ error = restore_init(in_fn, &mfd, printonly);
if (error != 0)
exit(error);
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
[gfs2-utils] 25/27: gfs2_convert: Fix the remaining sparse warnings
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 fc23b1f60b51e66b08731e9074fe71cd5f68481c
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Fri Jun 11 16:26:03 2021 +0100
gfs2_convert: Fix the remaining sparse warnings
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/convert/gfs2_convert.c | 67 ++++++++++++++++++++-------------------------
1 file changed, 29 insertions(+), 38 deletions(-)
diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c
index fdcdce54..99a2fa76 100644
--- a/gfs2/convert/gfs2_convert.c
+++ b/gfs2/convert/gfs2_convert.c
@@ -272,7 +272,7 @@ static void mp_gfs1_to_gfs2(struct gfs2_sbd *sbp, int gfs1_h, int gfs2_h,
/* actual data blocks intact. */
/* ------------------------------------------------------------------------- */
static void fix_metatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
- struct blocklist *blk, uint64_t *first_nonzero_ptr,
+ struct blocklist *blk, __be64 *first_nonzero_ptr,
unsigned int size)
{
uint64_t block;
@@ -503,7 +503,8 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip, str
struct blocklist *blk, *newblk;
struct gfs2_buffer_head *bh, *dibh = ip->i_bh;
osi_list_t *tmp;
- uint64_t *ptr1, block;
+ uint64_t block;
+ __be64 *ptr1;
int h, ptrnum;
int bufsize = sbp->sd_bsize - sizeof(struct gfs_indirect);
@@ -537,7 +538,7 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip, str
if (blk->height >= ip->i_height - 1)
continue;
- for (ptr1 = (uint64_t *)blk->ptrbuf, ptrnum = 0;
+ for (ptr1 = (__be64 *)blk->ptrbuf, ptrnum = 0;
ptrnum < sbp->sd_inptrs; ptr1++, ptrnum++) {
if (!*ptr1)
continue;
@@ -585,7 +586,7 @@ static int fix_ind_reg_or_dir(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint3
uint32_t gfs2_hgt, struct blocklist *blk, struct blocklist *blocks)
{
unsigned int len, bufsize;
- uint64_t *ptr1, *ptr2;
+ __be64 *ptr1, *ptr2;
int ptrnum;
struct metapath gfs2mp;
@@ -599,14 +600,14 @@ static int fix_ind_reg_or_dir(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint3
That's a problem if the file system is full.
So I'm trying to truncate the data at the start and end
of the buffers (i.e. write only what we need to). */
- for (ptr1 = (uint64_t *)blk->ptrbuf, ptrnum = 0;
+ for (ptr1 = (__be64 *)blk->ptrbuf, ptrnum = 0;
ptrnum < sbp->sd_inptrs; ptr1++, ptrnum++) {
if (*ptr1 != 0x00)
break;
len -= sizeof(uint64_t);
}
/* Skip zero bytes at the end of the buffer */
- ptr2 = (uint64_t *)(blk->ptrbuf + bufsize) - 1;
+ ptr2 = (__be64 *)(blk->ptrbuf + bufsize) - 1;
while (len > 0 && *ptr2 == 0) {
ptr2--;
len -= sizeof(uint64_t);
@@ -630,7 +631,8 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint32_t d
/*FIXME: Messages here should be different, to not conflit with messages in get_inode_metablocks */
struct blocklist *newblk;
unsigned int len, bufsize;
- uint64_t *ptr1, block;
+ uint64_t block;
+ __be64 *ptr1;
int ptrnum, h;
struct metapath gfs2mp;
struct gfs2_buffer_head *bh;
@@ -640,7 +642,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint32_t d
* For each metadata block that holds jdata block pointers,
* get the blk pointers and copy them block by block
*/
- for (ptr1 = (uint64_t *) blk->ptrbuf, ptrnum = 0;
+ for (ptr1 = (__be64 *)blk->ptrbuf, ptrnum = 0;
ptrnum < sbp->sd_inptrs; ptr1++, ptrnum++) {
if (!*ptr1)
continue;
@@ -1156,7 +1158,7 @@ static int process_dirent_info(struct gfs2_inode *dip, struct gfs2_sbd *sbp,
if (dentmod) {
if (dent->de_type == cpu_to_be16(DT_LNK)
- && cpu_to_be64(dent->de_inum.no_addr) == dentmod) {
+ && be64_to_cpu(dent->de_inum.no_addr) == dentmod) {
dent->de_type = cpu_to_be16(DT_DIR);
error = -EISDIR;
break;
@@ -1266,8 +1268,8 @@ static int fix_one_directory_exhash(struct gfs2_sbd *sbp, struct gfs2_inode *dip
prev_leaf_block = 0;
/* for all the leafs, get the leaf block and process the dirents inside */
for (leaf_num = 0; ; leaf_num++) {
- uint64_t buf;
struct gfs2_leaf *leaf;
+ __be64 buf;
error = gfs2_readi(dip, (char *)&buf, leaf_num * sizeof(uint64_t),
sizeof(uint64_t));
@@ -1441,18 +1443,6 @@ static int fix_cdpn_symlinks(struct gfs2_sbd *sbp, osi_list_t *cdpn_to_fix)
return error;
} /* fix_cdpn_symlinks */
-/* ------------------------------------------------------------------------- */
-/* Fetch gfs1 jindex structure from buffer */
-/* ------------------------------------------------------------------------- */
-static void gfs1_jindex_in(struct gfs_jindex *jindex, char *buf)
-{
- struct gfs_jindex *str = (struct gfs_jindex *)buf;
-
- jindex->ji_addr = be64_to_cpu(str->ji_addr);
- jindex->ji_nsegment = be32_to_cpu(str->ji_nsegment);
- memset(jindex->ji_reserved, 0, 64);
-}
-
/* ------------------------------------------------------------------------- */
/* read_gfs1_jiindex - read the gfs1 jindex file. */
/* Returns: 0 on success, -1 on failure */
@@ -1488,7 +1478,7 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
ip->i_mode &= ~S_IFMT;
ip->i_mode |= S_IFDIR;
for (j = 0; ; j++) {
- struct gfs_jindex *journ;
+ uint32_t nseg;
error = gfs2_readi(ip, buf, j * sizeof(struct gfs_jindex),
sizeof(struct gfs_jindex));
@@ -1499,9 +1489,9 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
" journal index file.\n"));
goto fail;
}
- journ = sd_jindex + j;
- gfs1_jindex_in(journ, buf);
- sdp->jsize = (journ->ji_nsegment * 16 * sdp->sd_bsize) >> 20;
+ memcpy(sd_jindex + j, buf, sizeof(struct gfs_jindex));
+ nseg = be32_to_cpu(sd_jindex[j].ji_nsegment);
+ sdp->jsize = (nseg * 16 * sdp->sd_bsize) >> 20;
}
ip->i_mode = tmp_mode;
if(j * sizeof(struct gfs_jindex) != ip->i_size){
@@ -1833,7 +1823,6 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
{
int error = 0;
int j;
- struct gfs_jindex *jndx;
struct rgrp_tree *rgd, *rgdhigh;
struct osi_node *n, *next = NULL;
struct gfs2_meta_header mh = {0};
@@ -1845,9 +1834,12 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
log_notice(_("Converting journal space to rg space.\n"));
/* Go through each journal, converting them one by one */
for (j = 0; j < orig_journals; j++) { /* for each journal */
+ uint32_t ji_nsegs;
+ uint64_t ji_addr;
uint64_t size;
- jndx = &sd_jindex[j];
+ ji_nsegs = be32_to_cpu(sd_jindex[j].ji_nsegment);
+ ji_addr = be64_to_cpu(sd_jindex[j].ji_addr);
/* go through all rg index entries, keeping track of the
highest that's still in the first subdevice.
Note: we really should go through all of the rgindex because
@@ -1858,7 +1850,7 @@ 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->rt_addr < jndx->ji_addr &&
+ if (rgd->rt_addr < ji_addr &&
((rgdhigh == NULL) ||
(rgd->rt_addr > rgdhigh->rt_addr)))
rgdhigh = rgd;
@@ -1868,20 +1860,19 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
return -1;
}
log_info(_("Addr 0x%"PRIx64" comes after rg at addr 0x%"PRIx64"\n"),
- jndx->ji_addr, rgdhigh->rt_addr);
- ri_addr = jndx->ji_addr;
+ ji_addr, rgdhigh->rt_addr);
+ ri_addr = ji_addr;
/* Allocate a new rgd entry which includes rg and ri. */
rgd = rgrp_insert(&sdp->rgtree, ri_addr);
/* convert the gfs1 rgrp into a new gfs2 rgrp */
- size = jndx->ji_nsegment *
- be32_to_cpu(gfs1_sb.sb_seg_size);
+ size = ji_nsegs * be32_to_cpu(gfs1_sb.sb_seg_size);
rgd->rt_flags = 0;
rgd->rt_dinodes = 0;
- rgd->rt_addr = jndx->ji_addr; /* new rg addr becomes ji addr */
+ rgd->rt_addr = ji_addr; /* new rg addr becomes ji addr */
rgd->rt_length = rgrp_length(size, sdp); /* aka bitblocks */
- rgd->rt_data0 = jndx->ji_addr + rgd->rt_length;
+ rgd->rt_data0 = ji_addr + rgd->rt_length;
rgd->rt_data = size - rgd->rt_length;
/* Round down to nearest multiple of GFS2_NBBY */
while (rgd->rt_data & 0x03)
@@ -1921,16 +1912,16 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
static void update_inode_file(struct gfs2_sbd *sdp)
{
struct gfs2_inode *ip = sdp->md.inum;
- uint64_t buf;
+ __be64 buf;
int count;
-
+
buf = cpu_to_be64(sdp->md.next_inum);
count = gfs2_writei(ip, &buf, 0, sizeof(uint64_t));
if (count != sizeof(uint64_t)) {
fprintf(stderr, "update_inode_file\n");
exit(1);
}
-
+
log_debug(_("\nNext Inum: %llu\n"), (unsigned long long)sdp->md.next_inum);
}/* update_inode_file */
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
[gfs2-utils] 24/27: libgfs2: Fix the remaining sparse warnings
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 58f33f9c3e97b397fb0335621e90fd35cc6d2459
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Fri Jun 11 14:55:54 2021 +0100
libgfs2: Fix the remaining sparse warnings
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/libgfs2/fs_ops.c | 67 +++++++++++++++++++++++++++--------------------
gfs2/libgfs2/meta.c | 12 ++++-----
gfs2/libgfs2/recovery.c | 3 ++-
gfs2/libgfs2/rgrp.c | 2 +-
gfs2/libgfs2/structures.c | 9 +++----
5 files changed, 52 insertions(+), 41 deletions(-)
diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index e533b9de..eb695a3e 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
@@ -14,14 +14,14 @@
#include "libgfs2.h"
#include "rgrp.h"
-static __inline__ uint64_t *metapointer(char *buf,
+static __inline__ __be64 *metapointer(char *buf,
unsigned int height,
struct metapath *mp)
{
unsigned int head_size = (height > 0) ?
sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_dinode);
- return ((uint64_t *)(buf + head_size)) + mp->mp_list[height];
+ return ((__be64 *)(buf + head_size)) + mp->mp_list[height];
}
/* Detect directory is a stuffed inode */
@@ -272,7 +272,7 @@ void unstuff_dinode(struct gfs2_inode *ip)
buffer_clear_tail(sdp, ip->i_bh, sizeof(struct gfs2_dinode));
if (ip->i_size) {
- *(uint64_t *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode)) = cpu_to_be64(block);
+ *(__be64 *)(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_blocks++;
}
@@ -419,7 +419,7 @@ void build_height(struct gfs2_inode *ip, int height)
buffer_clear_tail(sdp, ip->i_bh, sizeof(struct gfs2_dinode));
if (new_block) {
- *(uint64_t *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode)) = cpu_to_be64(block);
+ *(__be64 *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode)) = cpu_to_be64(block);
/* no need: bmodified(ip->i_bh);*/
ip->i_blocks++;
}
@@ -444,7 +444,7 @@ void lookup_block(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
unsigned int height, struct metapath *mp,
int create, int *new, uint64_t *block)
{
- uint64_t *ptr = metapointer(bh->b_data, height, mp);
+ __be64 *ptr = metapointer(bh->b_data, height, mp);
if (*ptr) {
*block = be64_to_cpu(*ptr);
@@ -861,9 +861,10 @@ void dirent2_del(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,
bmodified(bh);
if (gfs2_check_meta(bh->b_data, GFS2_METATYPE_LF) == 0) {
struct gfs2_leaf *lf = (struct gfs2_leaf *)bh->b_data;
+ uint16_t entries;
- lf->lf_entries = be16_to_cpu(lf->lf_entries) - 1;
- lf->lf_entries = cpu_to_be16(lf->lf_entries);
+ entries = be16_to_cpu(lf->lf_entries) - 1;
+ lf->lf_entries = cpu_to_be16(entries);
}
if (dip->i_entries) {
@@ -885,9 +886,9 @@ void dirent2_del(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,
int lgfs2_get_leaf_ptr(struct gfs2_inode *dip, const uint32_t lindex, uint64_t *ptr)
{
- uint64_t leaf_no;
- int count = gfs2_readi(dip, (char *)&leaf_no, lindex * sizeof(uint64_t), sizeof(uint64_t));
- if (count != sizeof(uint64_t))
+ __be64 leaf_no;
+ int count = gfs2_readi(dip, (char *)&leaf_no, lindex * sizeof(__be64), sizeof(__be64));
+ if (count != sizeof(__be64))
return -1;
*ptr = be64_to_cpu(leaf_no);
@@ -901,7 +902,9 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
struct gfs2_leaf *nleaf, *oleaf;
struct gfs2_dirent *dent, *prev = NULL, *next = NULL, *new;
uint32_t len, half_len, divider;
- uint64_t bn, *lp;
+ uint16_t depth;
+ uint64_t bn;
+ __be64 *lp;
uint32_t name_len;
int x, moved = 0;
int count;
@@ -929,7 +932,7 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
len = 1 << (dip->i_depth - be16_to_cpu(oleaf->lf_depth));
half_len = len >> 1;
- lp = calloc(1, half_len * sizeof(uint64_t));
+ lp = calloc(1, half_len * sizeof(__be64));
if (lp == NULL) {
fprintf(stderr, "Out of memory in %s\n", __FUNCTION__);
exit(-1);
@@ -961,6 +964,8 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
if (dent->de_inum.no_formal_ino &&
be32_to_cpu(dent->de_hash) < divider) {
+ uint16_t entries;
+
name_len = be16_to_cpu(dent->de_name_len);
if (dirent_alloc(dip, nbh, name_len, &new)) {
@@ -973,8 +978,8 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
new->de_type = dent->de_type;
memcpy((char *)(new + 1), (char *)(dent + 1), name_len);
- nleaf->lf_entries = be16_to_cpu(nleaf->lf_entries) + 1;
- nleaf->lf_entries = cpu_to_be16(nleaf->lf_entries);
+ entries = be16_to_cpu(nleaf->lf_entries) + 1;
+ nleaf->lf_entries = cpu_to_be16(entries);
dirent2_del(dip, obh, prev, dent);
@@ -998,8 +1003,8 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
dip->i_entries--;
}
- oleaf->lf_depth = be16_to_cpu(oleaf->lf_depth) + 1;
- oleaf->lf_depth = cpu_to_be16(oleaf->lf_depth);
+ depth = be16_to_cpu(oleaf->lf_depth) + 1;
+ oleaf->lf_depth = cpu_to_be16(depth);
nleaf->lf_depth = oleaf->lf_depth;
nleaf->lf_inode = cpu_to_be64(dip->i_num.in_addr);
@@ -1162,6 +1167,8 @@ restart:
return err;
for (;;) {
+ uint16_t entries;
+
bh = bread(dip->i_sbd, leaf_no);
leaf = (struct gfs2_leaf *)bh->b_data;
@@ -1220,8 +1227,8 @@ restart:
dent->de_type = cpu_to_be16(type);
memcpy((char *)(dent + 1), filename, len);
- leaf->lf_entries = be16_to_cpu(leaf->lf_entries) + 1;
- leaf->lf_entries = cpu_to_be16(leaf->lf_entries);
+ entries = be16_to_cpu(leaf->lf_entries) + 1;
+ leaf->lf_entries = cpu_to_be16(entries);
bmodified(bh);
brelse(bh);
@@ -1235,9 +1242,11 @@ static void dir_make_exhash(struct gfs2_inode *dip)
struct gfs2_dirent *dent;
struct gfs2_buffer_head *bh;
struct gfs2_leaf *leaf;
+ uint16_t rec_len;
int y;
uint32_t x;
- uint64_t *lp, bn;
+ uint64_t bn;
+ __be64 *lp;
if (lgfs2_meta_alloc(dip, &bn))
exit(1);
@@ -1269,16 +1278,16 @@ static void dir_make_exhash(struct gfs2_inode *dip)
break;
} while (gfs2_dirent_next(dip, bh, &dent) == 0);
- dent->de_rec_len = be16_to_cpu(dent->de_rec_len);
- dent->de_rec_len = cpu_to_be16(dent->de_rec_len +
- sizeof(struct gfs2_dinode) - sizeof(struct gfs2_leaf));
+ rec_len = be16_to_cpu(dent->de_rec_len) +
+ sizeof(struct gfs2_dinode) - sizeof(struct gfs2_leaf);
+ dent->de_rec_len = cpu_to_be16(rec_len);
/* no need to: bmodified(bh); (buffer_copy_tail does it) */
brelse(bh);
buffer_clear_tail(sdp, dip->i_bh, sizeof(struct gfs2_dinode));
- lp = (uint64_t *)(dip->i_bh->b_data + sizeof(struct gfs2_dinode));
+ lp = (__be64 *)(dip->i_bh->b_data + sizeof(struct gfs2_dinode));
for (x = sdp->sd_hash_ptrs; x--; lp++)
*lp = cpu_to_be64(bn);
@@ -1300,6 +1309,7 @@ static int dir_l_add(struct gfs2_inode *dip, const char *filename, int len,
struct lgfs2_inum *inum, unsigned int type)
{
struct gfs2_dirent *dent;
+ uint32_t de_hash;
int err = 0;
if (dirent_alloc(dip, dip->i_bh, len, &dent)) {
@@ -1309,8 +1319,8 @@ static int dir_l_add(struct gfs2_inode *dip, const char *filename, int len,
}
lgfs2_inum_out(inum, &dent->de_inum);
- dent->de_hash = gfs2_disk_hash(filename, len);
- dent->de_hash = cpu_to_be32(dent->de_hash);
+ de_hash = gfs2_disk_hash(filename, len);
+ dent->de_hash = cpu_to_be32(de_hash);
dent->de_type = cpu_to_be16(type);
memcpy((char *)(dent + 1), filename, len);
bmodified(dip->i_bh);
@@ -1418,7 +1428,7 @@ static void lgfs2_fill_indir(char *start, char *end, uint64_t ptr0, unsigned n,
memset(start, 0, end - start);
for (bp = start; bp < end && *p < n; bp += sizeof(uint64_t)) {
uint64_t pn = ptr0 + *p;
- *(uint64_t *)bp = cpu_to_be64(pn);
+ *(__be64 *)bp = cpu_to_be64(pn);
(*p)++;
}
}
@@ -1918,9 +1928,10 @@ int gfs2_freedi(struct gfs2_sbd *sdp, uint64_t diblock)
struct gfs2_inode *ip;
struct gfs2_buffer_head *bh, *nbh;
int h, head_size;
- uint64_t *ptr, block;
+ uint64_t block;
struct rgrp_tree *rgd;
uint32_t height;
+ __be64 *ptr;
osi_list_t metalist[GFS2_MAX_META_HEIGHT];
osi_list_t *cur_list, *next_list, *tmp;
@@ -1946,7 +1957,7 @@ int gfs2_freedi(struct gfs2_sbd *sdp, uint64_t diblock)
bh = osi_list_entry(tmp, struct gfs2_buffer_head,
b_altlist);
- for (ptr = (uint64_t *)(bh->b_data + head_size);
+ for (ptr = (__be64 *)(bh->b_data + head_size);
(char *)ptr < (bh->b_data + sdp->sd_bsize); ptr++) {
if (!*ptr)
continue;
diff --git a/gfs2/libgfs2/meta.c b/gfs2/libgfs2/meta.c
index db5f37b1..5d8811a6 100644
--- a/gfs2/libgfs2/meta.c
+++ b/gfs2/libgfs2/meta.c
@@ -873,13 +873,13 @@ int lgfs2_field_str(char *str, const size_t size, const char *blk, const struct
value = *(uint8_t *)fieldp;
break;
case sizeof(uint16_t):
- value = be16_to_cpu(*(uint16_t *)fieldp);
+ value = be16_to_cpu(*(__be16 *)fieldp);
break;
case sizeof(uint32_t):
- value = be32_to_cpu(*(uint32_t *)fieldp);
+ value = be32_to_cpu(*(__be32 *)fieldp);
break;
case sizeof(uint64_t):
- value = be64_to_cpu(*(uint64_t *)fieldp);
+ value = be64_to_cpu(*(__be64 *)fieldp);
break;
default:
*str = 0;
@@ -948,13 +948,13 @@ int lgfs2_field_assign(char *blk, const struct lgfs2_metafield *field, const voi
*fieldp = (uint8_t)num;
return 0;
case sizeof(uint16_t):
- *(uint16_t *)fieldp = cpu_to_be16((uint16_t)num);
+ *(__be16 *)fieldp = cpu_to_be16((uint16_t)num);
return 0;
case sizeof(uint32_t):
- *(uint32_t *)fieldp = cpu_to_be32((uint32_t)num);
+ *(__be32 *)fieldp = cpu_to_be32((uint32_t)num);
return 0;
case sizeof(uint64_t):
- *(uint64_t *)fieldp = cpu_to_be64((uint64_t)num);
+ *(__be64 *)fieldp = cpu_to_be64((uint64_t)num);
return 0;
default:
/* Will never happen */
diff --git a/gfs2/libgfs2/recovery.c b/gfs2/libgfs2/recovery.c
index 9234a867..f4cea511 100644
--- a/gfs2/libgfs2/recovery.c
+++ b/gfs2/libgfs2/recovery.c
@@ -71,7 +71,8 @@ int lgfs2_get_log_header(struct gfs2_inode *ip, unsigned int blk,
struct gfs2_buffer_head *bh;
struct lgfs2_log_header lh;
struct gfs2_log_header *tmp;
- uint32_t hash, saved_hash;
+ __be32 saved_hash;
+ uint32_t hash;
uint32_t lh_crc = 0;
uint32_t crc;
int error;
diff --git a/gfs2/libgfs2/rgrp.c b/gfs2/libgfs2/rgrp.c
index 454f6e60..335060c4 100644
--- a/gfs2/libgfs2/rgrp.c
+++ b/gfs2/libgfs2/rgrp.c
@@ -157,7 +157,7 @@ int lgfs2_rgrp_crc_check(char *buf)
{
int ret = 0;
struct gfs2_rgrp *rg = (struct gfs2_rgrp *)buf;
- uint32_t crc = rg->rg_crc;
+ __be32 crc = rg->rg_crc;
if (crc == 0)
return 0;
diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c
index ae5de7e1..a562dc50 100644
--- a/gfs2/libgfs2/structures.c
+++ b/gfs2/libgfs2/structures.c
@@ -589,7 +589,7 @@ int build_root(struct gfs2_sbd *sdp)
int do_init_inum(struct gfs2_sbd *sdp)
{
struct gfs2_inode *ip = sdp->md.inum;
- uint64_t buf;
+ __be64 buf;
int count;
buf = cpu_to_be64(sdp->md.next_inum);
@@ -626,11 +626,10 @@ int do_init_statfs(struct gfs2_sbd *sdp)
int gfs2_check_meta(const char *buf, int type)
{
- uint32_t check_magic = ((struct gfs2_meta_header *)buf)->mh_magic;
- uint32_t check_type = ((struct gfs2_meta_header *)buf)->mh_type;
+ struct gfs2_meta_header *mh = (struct gfs2_meta_header *)buf;
+ uint32_t check_magic = be32_to_cpu(mh->mh_magic);
+ uint32_t check_type = be32_to_cpu(mh->mh_type);
- check_magic = be32_to_cpu(check_magic);
- check_type = be32_to_cpu(check_type);
if((check_magic != GFS2_MAGIC) || (type && (check_type != type)))
return -1;
return 0;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
[gfs2-utils] 23/27: fsck.gfs2: Remove unused invalidate_fxns
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 d5e853c90bf3988ff28793abe76f4f9edae6f308
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Fri Jun 11 14:01:12 2021 +0100
fsck.gfs2: Remove unused invalidate_fxns
Introduced in 00f523c4 "fsck.gfs2: invalidate invalid mode inodes"
Unused since 5e7c6711 "fsck.gfs2: Do not invalidate metablocks of
dinodes with invalid mode"
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/fsck/pass1.c | 101 ------------------------------------------------------
1 file changed, 101 deletions(-)
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index d619a972..465cbceb 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -997,107 +997,6 @@ static int check_eattr_entries(struct gfs2_inode *ip,
return 0;
}
-/**
- * mark_block_invalid - mark blocks associated with an inode as invalid
- * unless the block is a duplicate.
- *
- * An "invalid" block is now considered free in the bitmap, and pass2 will
- * delete any invalid blocks. This is nearly identical to function
- * delete_block_if_notdup.
- */
-static int mark_block_invalid(struct gfs2_inode *ip, uint64_t block,
- enum dup_ref_type reftype, const char *btype,
- int *is_valid, int *was_duplicate)
-{
- int q;
-
- /* If the block isn't valid, we obviously can't invalidate it.
- * However, if we return an error, invalidating will stop, and
- * we want it to continue to invalidate the valid blocks. If we
- * don't do this, block references that follow that are also
- * referenced elsewhere (duplicates) won't be flagged as such,
- * and as a result, they'll be freed when this dinode is deleted,
- * despite being used by another dinode as a valid block. */
- if (is_valid)
- *is_valid = 1;
- if (was_duplicate)
- *was_duplicate = 0;
- if (!valid_block_ip(ip, block)) {
- if (is_valid)
- *is_valid = 0;
- return META_IS_GOOD;
- }
-
- q = block_type(bl, block);
- if (q != GFS2_BLKST_FREE) {
- if (was_duplicate)
- *was_duplicate = 1;
- add_duplicate_ref(ip, block, reftype, 0, INODE_INVALID);
- 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_num.in_addr, ip->i_num.in_addr);
- return META_IS_GOOD;
- }
- fsck_blockmap_set(ip, block, btype, GFS2_BLKST_UNLINKED);
- return META_IS_GOOD;
-}
-
-static int invalidate_metadata(struct iptr iptr, struct gfs2_buffer_head **bh, int h,
- int *is_valid, int *was_duplicate, void *private)
-{
- struct gfs2_inode *ip = iptr.ipt_ip;
- uint64_t block = iptr_block(iptr);
-
- *is_valid = 1;
- *was_duplicate = 0;
- return mark_block_invalid(ip, block, REF_AS_META, _("metadata"),
- is_valid, was_duplicate);
-}
-
-static int invalidate_leaf(struct gfs2_inode *ip, uint64_t block,
- void *private)
-{
- return mark_block_invalid(ip, block, REF_AS_META, _("leaf"),
- NULL, NULL);
-}
-
-static int invalidate_data(struct gfs2_inode *ip, uint64_t metablock,
- uint64_t block, void *private,
- struct gfs2_buffer_head *bh, __be64 *ptr)
-{
- return mark_block_invalid(ip, block, REF_AS_DATA, _("data"),
- NULL, NULL);
-}
-
-static int invalidate_eattr_indir(struct gfs2_inode *ip, uint64_t block,
- uint64_t parent,
- struct gfs2_buffer_head **bh, void *private)
-{
- return mark_block_invalid(ip, block, REF_AS_EA,
- _("indirect extended attribute"),
- NULL, NULL);
-}
-
-static int invalidate_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
- uint64_t parent, struct gfs2_buffer_head **bh,
- void *private)
-{
- return mark_block_invalid(ip, block, REF_AS_EA,
- _("extended attribute"),
- NULL, NULL);
-}
-
-static struct metawalk_fxns invalidate_fxns = {
- .private = NULL,
- .check_metalist = invalidate_metadata,
- .check_data = invalidate_data,
- .check_leaf = invalidate_leaf,
- .check_eattr_indir = invalidate_eattr_indir,
- .check_eattr_leaf = invalidate_eattr_leaf,
- .delete_block = delete_block,
-};
-
/**
* Check for massive amounts of pointer corruption. If the block has
* lots of out-of-range pointers, we can't trust any of the pointers.
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
[gfs2-utils] 22/27: Fix sparse warnings about linkage
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 e57ccf23dae464ee692531c54edb50dff7206340
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Fri Jun 11 13:57:22 2021 +0100
Fix sparse warnings about linkage
Fixes a bajillion cases of "warning: symbol '<symbol>' was not declared.
Should it be static?"
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/convert/gfs2_convert.c | 37 +++++++++++++++--------------
gfs2/edit/extended.c | 2 --
gfs2/edit/gfs2hex.c | 4 ++--
gfs2/edit/gfs2hex.h | 1 +
gfs2/edit/hexedit.c | 16 ++++---------
gfs2/edit/hexedit.h | 1 +
gfs2/edit/journal.c | 2 --
gfs2/edit/savemeta.c | 9 ++++---
gfs2/fsck/fs_recovery.c | 16 +++++++------
gfs2/fsck/fsck.h | 1 +
gfs2/fsck/initialize.c | 1 -
gfs2/fsck/main.c | 13 ++++++-----
gfs2/fsck/pass1.c | 18 +++++++-------
gfs2/fsck/pass2.c | 12 +++++-----
gfs2/fsck/pass4.c | 2 +-
gfs2/fsck/rgrepair.c | 4 ++--
gfs2/glocktop/glocktop.c | 57 ++++++++++++++++++++++-----------------------
gfs2/mkfs/main_mkfs.c | 2 +-
gfs2/tune/main.c | 5 ++--
tests/nukerg.c | 2 +-
20 files changed, 99 insertions(+), 106 deletions(-)
diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c
index 5228c532..fdcdce54 100644
--- a/gfs2/convert/gfs2_convert.c
+++ b/gfs2/convert/gfs2_convert.c
@@ -94,24 +94,25 @@ struct gfs2_options {
unsigned int query:1;
};
-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 */
-int seconds;
-struct timeval tv;
-uint64_t dirs_fixed;
-uint64_t cdpns_fixed;
-uint64_t dirents_fixed;
-struct gfs_jindex *sd_jindex = NULL; /* gfs1 journal index in memory */
-int gfs2_inptrs;
-uint64_t gfs2_heightsize[GFS2_MAX_META_HEIGHT];
-uint64_t gfs2_jheightsize[GFS2_MAX_META_HEIGHT];
-uint32_t gfs2_max_height;
-uint32_t gfs2_max_jheight;
-uint64_t jindex_addr = 0, rindex_addr = 0;
+static struct gfs_sb gfs1_sb;
+static struct gfs2_sbd sb2;
+static struct inode_block dirs_to_fix; /* linked list of directories to fix */
+static struct inode_dir_block cdpns_to_fix; /* linked list of cdpn symlinks */
+static int seconds;
+static struct timeval tv;
+static uint64_t dirs_fixed;
+static uint64_t cdpns_fixed;
+static uint64_t dirents_fixed;
+static struct gfs_jindex *sd_jindex = NULL; /* gfs1 journal index in memory */
+static int gfs2_inptrs;
+static uint64_t gfs2_heightsize[GFS2_MAX_META_HEIGHT];
+static uint64_t gfs2_jheightsize[GFS2_MAX_META_HEIGHT];
+static uint32_t gfs2_max_height;
+static uint32_t gfs2_max_jheight;
+static uint64_t jindex_addr = 0, rindex_addr = 0;
+static unsigned orig_journals = 0;
+
int print_level = MSG_NOTICE;
-unsigned orig_journals = 0;
/* ------------------------------------------------------------------------- */
/* This function is for libgfs's sake. */
@@ -773,7 +774,7 @@ out:
return error;
}
-const char *cdpn[14] = {"{hostname}", "{mach}", "{os}", "{uid}", "{gid}", "{sys}", "{jid}",
+static const char *cdpn[14] = {"{hostname}", "{mach}", "{os}", "{uid}", "{gid}", "{sys}", "{jid}",
"@hostname", "@mach", "@os", "@uid", "@gid", "@sys", "@jid"};
static int has_cdpn(const char *str)
{
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index 92dbb415..d6e4624a 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -25,8 +25,6 @@
#include "extended.h"
#include "gfs2hex.h"
-extern uint64_t block;
-
static void print_block_details(struct iinfo *ind, int level, int cur_height,
int pndx, uint64_t file_offset);
diff --git a/gfs2/edit/gfs2hex.c b/gfs2/edit/gfs2hex.c
index d1878639..95572fef 100644
--- a/gfs2/edit/gfs2hex.c
+++ b/gfs2/edit/gfs2hex.c
@@ -28,7 +28,7 @@
} while(0)
struct gfs2_dinode *di;
-int line, termlines, modelines[DMODES];
+int line, termlines;
char edit_fmt[80];
char estring[1024];
char efield[64];
@@ -63,7 +63,7 @@ const char *termtype;
WINDOW *wind;
int dsplines = 0;
-const char *block_type_str[15] = {
+static const char *block_type_str[15] = {
"Clump",
"Superblock",
"Resource Group Header",
diff --git a/gfs2/edit/gfs2hex.h b/gfs2/edit/gfs2hex.h
index a86e3a4c..14230ffa 100644
--- a/gfs2/edit/gfs2hex.h
+++ b/gfs2/edit/gfs2hex.h
@@ -9,5 +9,6 @@ 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);
+extern uint64_t block;
#endif /* __GFS2HEX_DOT_H__ */
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index 00f5aa03..fd7388ce 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -36,19 +36,13 @@ const char *allocdesc[2][5] = {
{"Free ", "Data ", "Unlnk", "Meta ", "Resrv"},
{"Free ", "Data ", "FreeM", "Meta ", "Resrv"},};
-struct gfs2_buffer_head *bh;
-struct gfs2_rgrp *lrgrp;
-struct gfs2_meta_header *lmh;
-struct gfs2_dinode *ldi;
-struct gfs2_leaf *lleaf;
-struct gfs2_log_header *llh;
-struct gfs2_log_descriptor *lld;
-int pgnum;
-int details = 0;
-long int gziplevel = 9;
+static struct gfs2_buffer_head *bh;
+static int pgnum;
+static long int gziplevel = 9;
static int termcols;
+
+int details = 0;
char *device = NULL;
-extern uint64_t block;
/* ------------------------------------------------------------------------- */
/* erase - clear the screen */
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index adbeb742..e48c5885 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -62,6 +62,7 @@ extern int dsp_lines[DMODES];
extern int combined_display;
extern int details;
extern const char *allocdesc[2][5];
+extern char *device;
struct idirent {
struct lgfs2_inum inum;
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index 1baba02f..d7710c2b 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -26,8 +26,6 @@
#include "gfs2hex.h"
#include "journal.h"
-extern uint64_t block;
-
/**
* find_journal_block - figure out where a journal starts, given the name
* Returns: journal block number, changes j_size to the journal size
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index a99930c2..473a2d03 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -60,9 +60,9 @@ struct metafd {
const char* (*strerr)(struct metafd *mfd);
};
-char *restore_buf;
-ssize_t restore_left;
-off_t restore_off;
+static char *restore_buf;
+static ssize_t restore_left;
+static off_t restore_off;
#define RESTORE_BUF_SIZE (2 * 1024 * 1024)
static char *restore_buf_next(struct metafd *mfd, size_t required_len)
@@ -184,7 +184,6 @@ static uint64_t journal_blocks[MAX_JOURNALS_SAVED];
static uint64_t gfs1_journal_size = 0; /* in blocks */
static int journals_found = 0;
int print_level = MSG_NOTICE;
-extern char *device;
static int block_is_a_journal(uint64_t blk)
{
@@ -196,7 +195,7 @@ static int block_is_a_journal(uint64_t blk)
return FALSE;
}
-struct osi_root per_node_tree;
+static struct osi_root per_node_tree;
struct per_node_node {
struct osi_node node;
uint64_t block;
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index e6744dc2..b62f7a65 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -19,11 +19,13 @@
#define JOURNAL_NAME_SIZE 18
#define JOURNAL_SEQ_TOLERANCE 10
-unsigned int sd_found_jblocks = 0, sd_replayed_jblocks = 0;
-unsigned int sd_found_metablocks = 0, sd_replayed_metablocks = 0;
-unsigned int sd_found_revokes = 0;
-osi_list_t sd_revoke_list;
-unsigned int sd_replay_tail;
+static unsigned int sd_found_jblocks = 0;
+static unsigned int sd_replayed_jblocks = 0;
+static unsigned int sd_found_metablocks = 0;
+static unsigned int sd_replayed_metablocks = 0;
+static unsigned int sd_found_revokes = 0;
+static osi_list_t sd_revoke_list;
+static unsigned int sd_replay_tail;
struct gfs2_revoke_replay {
osi_list_t rr_list;
@@ -666,7 +668,7 @@ static int rangecheck_jdata(struct gfs2_inode *ip, uint64_t metablock,
return rangecheck_jblock(ip, block);
}
-struct metawalk_fxns rangecheck_journal = {
+static struct metawalk_fxns rangecheck_journal = {
.private = NULL,
.invalid_meta_is_fatal = 1,
.check_metalist = rangecheck_jmeta,
@@ -854,7 +856,7 @@ dirent_good:
return 0;
}
-struct metawalk_fxns jindex_check_fxns = {
+static struct metawalk_fxns jindex_check_fxns = {
.private = NULL,
.check_dentry = check_jindex_dent,
};
diff --git a/gfs2/fsck/fsck.h b/gfs2/fsck/fsck.h
index 55f5abe8..91ef23d1 100644
--- a/gfs2/fsck/fsck.h
+++ b/gfs2/fsck/fsck.h
@@ -199,5 +199,6 @@ struct special_blocks {
extern struct special_blocks *blockfind(struct special_blocks *blist, uint64_t num);
extern void gfs2_special_set(struct special_blocks *blocklist, uint64_t block);
extern void gfs2_special_free(struct special_blocks *blist);
+extern int sb_fixed;
#endif /* _FSCK_H */
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 039a0fd7..4bc7eef6 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -34,7 +34,6 @@ static int was_mounted_ro = 0;
static uint64_t possible_root = HIGHEST_BLOCK;
static struct master_dir fix_md;
static unsigned long long blks_2free = 0;
-extern int sb_fixed;
/**
* block_mounters
diff --git a/gfs2/fsck/main.c b/gfs2/fsck/main.c
index a7ea9bf2..b528b5ee 100644
--- a/gfs2/fsck/main.c
+++ b/gfs2/fsck/main.c
@@ -32,18 +32,19 @@ uint64_t last_fs_block, last_reported_block = -1;
int64_t last_reported_fblock = -1000000;
int skip_this_pass = 0, fsck_abort = 0;
int errors_found = 0, errors_corrected = 0;
-const char *pass = "";
uint64_t last_data_block;
uint64_t first_data_block;
-int preen = 0, force_check = 0;
struct osi_root dup_blocks;
struct osi_root dirtree;
struct osi_root inodetree;
int dups_found = 0, dups_found_first = 0;
-struct gfs_sb *sbd1 = NULL;
int sb_fixed = 0;
int print_level = MSG_NOTICE;
+static int preen = 0;
+static int force_check = 0;
+static const char *pass_name = "";
+
/* This function is for libgfs2's sake. */
void print_it(const char *label, const char *fmt, const char *fmt2, ...)
{
@@ -148,8 +149,8 @@ static void interrupt(int sig)
sprintf(progress, _("processing block %llu out of %llu\n"),
(unsigned long long)last_reported_block,
(unsigned long long)last_fs_block);
-
- response = generic_interrupt("fsck.gfs2", pass, progress,
+
+ response = generic_interrupt("fsck.gfs2", pass_name, progress,
_("Do you want to abort fsck.gfs2, skip " \
"the rest of this pass or continue " \
"(a/s/c)?"), "asc");
@@ -253,7 +254,7 @@ static int fsck_pass(const struct fsck_pass *p, struct gfs2_sbd *sdp)
if (fsck_abort)
return FSCK_CANCELED;
- pass = p->name;
+ pass_name = p->name;
log_notice( _("Starting %s\n"), p->name);
gettimeofday(&timer, NULL);
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 8a8ce97c..d619a972 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -29,8 +29,8 @@
#include "metawalk.h"
#include "fs_recovery.h"
-struct special_blocks gfs1_rindex_blks;
-struct gfs2_bmap *bl = NULL;
+static struct special_blocks gfs1_rindex_blks;
+static struct gfs2_bmap *bl = NULL;
struct block_count {
uint64_t indir_count;
@@ -164,7 +164,7 @@ out:
return 0;
}
-struct metawalk_fxns pass1_fxns = {
+static struct metawalk_fxns pass1_fxns = {
.private = NULL,
.check_leaf = p1check_leaf,
.check_metalist = pass1_check_metalist,
@@ -265,7 +265,7 @@ static int resuscitate_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
return 0;
}
-struct metawalk_fxns sysdir_fxns = {
+static struct metawalk_fxns sysdir_fxns = {
.private = NULL,
.check_metalist = resuscitate_metalist,
.check_dentry = resuscitate_dentry,
@@ -1088,7 +1088,7 @@ static int invalidate_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
NULL, NULL);
}
-struct metawalk_fxns invalidate_fxns = {
+static struct metawalk_fxns invalidate_fxns = {
.private = NULL,
.check_metalist = invalidate_metadata,
.check_data = invalidate_data,
@@ -1111,7 +1111,7 @@ struct metawalk_fxns invalidate_fxns = {
* Returns: 0 if good range, otherwise != 0
*/
enum b_types { BTYPE_META, BTYPE_LEAF, BTYPE_DATA, BTYPE_IEATTR, BTYPE_EATTR};
-const char *btypes[5] = {
+static const char *btypes[5] = {
"metadata", "leaf", "data", "indirect extended attribute",
"extended attribute" };
@@ -1189,7 +1189,7 @@ static int rangecheck_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
return rangecheck_block(ip, block, NULL, BTYPE_EATTR, private);
}
-struct metawalk_fxns rangecheck_fxns = {
+static struct metawalk_fxns rangecheck_fxns = {
.private = NULL,
.readahead = 1,
.check_metalist = rangecheck_metadata,
@@ -1200,7 +1200,7 @@ struct metawalk_fxns rangecheck_fxns = {
.delete_block = delete_block,
};
-struct metawalk_fxns eattr_undo_fxns = {
+static struct metawalk_fxns eattr_undo_fxns = {
.private = NULL,
.check_eattr_indir = undo_eattr_indir_or_leaf,
.check_eattr_leaf = undo_eattr_indir_or_leaf,
@@ -1319,7 +1319,7 @@ static int alloc_leaf(struct gfs2_inode *ip, uint64_t block, void *private)
return 0;
}
-struct metawalk_fxns alloc_fxns = {
+static struct metawalk_fxns alloc_fxns = {
.private = NULL,
.check_leaf = alloc_leaf,
.check_metalist = alloc_metalist,
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 98a0a4b8..6592edaf 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -21,9 +21,9 @@
#define MAX_FILENAME 256
-struct metawalk_fxns pass2_fxns;
+static struct metawalk_fxns pass2_fxns;
-struct metawalk_fxns delete_eattrs = {
+static struct metawalk_fxns delete_eattrs = {
.check_eattr_indir = delete_eattr_indir,
.check_eattr_leaf = delete_eattr_leaf,
.check_eattr_entry = delete_eattr_entry,
@@ -144,7 +144,7 @@ static int check_file_type(uint64_t block, uint8_t de_type, int q,
return *isdir;
}
-struct metawalk_fxns pass2_fxns_delete = {
+static struct metawalk_fxns pass2_fxns_delete = {
.private = NULL,
.check_metalist = delete_metadata,
.check_data = delete_data,
@@ -1262,7 +1262,7 @@ out:
* We don't want it to do the "wrong leaf" thing, or set_parent_dir either.
* We just want a basic sanity check on pointers and lengths.
*/
-struct metawalk_fxns leafck_fxns = {
+static struct metawalk_fxns leafck_fxns = {
.check_leaf_depth = check_leaf_depth,
.check_dentry = basic_check_dentry,
.repair_leaf = pass2_repair_leaf,
@@ -1766,7 +1766,7 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
return error;
}
-struct metawalk_fxns pass2_fxns = {
+static struct metawalk_fxns pass2_fxns = {
.private = NULL,
.check_leaf_depth = check_leaf_depth,
.check_leaf = NULL,
@@ -1815,7 +1815,7 @@ static int check_data_qc(struct gfs2_inode *ip, uint64_t metablock,
return 0;
}
-struct metawalk_fxns quota_change_fxns = {
+static struct metawalk_fxns quota_change_fxns = {
.check_metalist = check_metalist_qc,
.check_data = check_data_qc,
};
diff --git a/gfs2/fsck/pass4.c b/gfs2/fsck/pass4.c
index 0891e143..6da95726 100644
--- a/gfs2/fsck/pass4.c
+++ b/gfs2/fsck/pass4.c
@@ -16,7 +16,7 @@
#include "util.h"
#include "afterpass1_common.h"
-struct metawalk_fxns pass4_fxns_delete = {
+static struct metawalk_fxns pass4_fxns_delete = {
.private = NULL,
.check_metalist = delete_metadata,
.check_data = delete_data,
diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c
index da62cc47..6698b29c 100644
--- a/gfs2/fsck/rgrepair.c
+++ b/gfs2/fsck/rgrepair.c
@@ -16,8 +16,8 @@
#include "fsck.h"
#include "fs_recovery.h"
-int rindex_modified = 0;
-struct special_blocks false_rgrps;
+static int rindex_modified = 0;
+static struct special_blocks false_rgrps;
#define BAD_RG_PERCENT_TOLERANCE 11
#define AWAY_FROM_BITMAPS 0x1000
diff --git a/gfs2/glocktop/glocktop.c b/gfs2/glocktop/glocktop.c
index 437ee0ba..20852b27 100644
--- a/gfs2/glocktop/glocktop.c
+++ b/gfs2/glocktop/glocktop.c
@@ -143,14 +143,14 @@ enum summary_types {
stypes = 7,
};
-char *debugfs;
-int termcols = 80, termlines = 30, done = 0;
-unsigned glocks = 0;
-const char *termtype;
-WINDOW *wind;
-int bufsize = 4 * 1024 * 1024;
-char *glock[MAX_GLOCKS];
-int iterations = 0, show_reservations = 0, iters_done = 0;
+static char *debugfs;
+static int termcols = 80, termlines = 30, done = 0;
+static unsigned glocks = 0;
+static const char *termtype;
+static WINDOW *wind;
+static int bufsize = 4 * 1024 * 1024;
+static char *glock[MAX_GLOCKS];
+static int iterations = 0, show_reservations = 0, iters_done = 0;
struct mount_point {
struct mount_point *next;
char *device;
@@ -158,27 +158,26 @@ struct mount_point {
int fd;
struct gfs2_sbd sb;
};
-struct mount_point *mounts;
-char dlmwlines[MAX_LINES][96]; /* waiters lines */
-char dlmglines[MAX_LINES][97]; /* granted lines */
-char contended_filenames[MAX_FILES][PATH_MAX];
-unsigned long long contended_blocks[MAX_FILES];
-int contended_count = 0;
-int line = 0;
-const char *prog_name;
-char dlm_dirtbl_size[32], dlm_rsbtbl_size[32], dlm_lkbtbl_size[32];
-int bsize = 0;
-char print_dlm_grants = 1;
-char *gbuf = NULL; /* glocks buffer */
-char *gpos = NULL;
-char *gnextpos = NULL;
-int gmaxpos = 0;
-
-char *dbuf = NULL; /* dlm locks buffer */
-char *dpos = NULL;
-char *dnextpos = NULL;
-int dmaxpos = 0;
-char hostname[256];
+static struct mount_point *mounts;
+static char dlmwlines[MAX_LINES][96]; /* waiters lines */
+static char dlmglines[MAX_LINES][97]; /* granted lines */
+static char contended_filenames[MAX_FILES][PATH_MAX];
+static unsigned long long contended_blocks[MAX_FILES];
+static int contended_count = 0;
+static int line = 0;
+static const char *prog_name;
+static char dlm_dirtbl_size[32], dlm_rsbtbl_size[32], dlm_lkbtbl_size[32];
+static int bsize = 0;
+static char print_dlm_grants = 1;
+static char *gbuf = NULL; /* glocks buffer */
+static char *gpos = NULL;
+static char *gnextpos = NULL;
+static int gmaxpos = 0;
+static char *dbuf = NULL; /* dlm locks buffer */
+static char *dpos = NULL;
+static char *dnextpos = NULL;
+static int dmaxpos = 0;
+static char hostname[256];
/*
* init_colors
diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c
index bca7b9d1..da82d462 100644
--- a/gfs2/mkfs/main_mkfs.c
+++ b/gfs2/mkfs/main_mkfs.c
@@ -160,7 +160,7 @@ static void opts_init(struct mkfs_opts *opts)
opts->format = GFS2_FORMAT_FS;
}
-struct lgfs2_inum *mkfs_journals = NULL;
+static struct lgfs2_inum *mkfs_journals = NULL;
#ifndef BLKDISCARD
#define BLKDISCARD _IO(0x12,119)
diff --git a/gfs2/tune/main.c b/gfs2/tune/main.c
index d5998071..fe137803 100644
--- a/gfs2/tune/main.c
+++ b/gfs2/tune/main.c
@@ -16,9 +16,8 @@
#include <unistd.h>
#include "tunegfs2.h"
-struct tunegfs2 tunegfs2_struct;
-struct tunegfs2 *tfs = &tunegfs2_struct;
-
+static struct tunegfs2 tunegfs2_struct;
+static struct tunegfs2 *tfs = &tunegfs2_struct;
static void parse_mount_options(char *arg)
{
diff --git a/tests/nukerg.c b/tests/nukerg.c
index 399f7373..74b65abb 100644
--- a/tests/nukerg.c
+++ b/tests/nukerg.c
@@ -10,7 +10,7 @@
#include <libgfs2.h>
-const char *prog_name = "nukerg";
+static const char *prog_name = "nukerg";
static void usage(void)
{
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
[gfs2-utils] 21/27: libgfs2: Remove gfs_jindex_in
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 ad63b07a833a886165dad91576101c2882346989
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Fri Jun 11 12:50:50 2021 +0100
libgfs2: Remove gfs_jindex_in
Also fix some endianness tagging in gfs1.c so that it's now
sparse-clean.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/edit/extended.c | 14 +++++++-------
gfs2/edit/hexedit.h | 1 -
gfs2/edit/journal.c | 7 +++----
gfs2/edit/savemeta.c | 8 ++++----
gfs2/fsck/fs_recovery.c | 7 ++++---
gfs2/fsck/initialize.c | 16 ++++++++--------
gfs2/libgfs2/gfs1.c | 19 +++----------------
gfs2/libgfs2/libgfs2.h | 1 -
8 files changed, 29 insertions(+), 44 deletions(-)
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index 975a514c..92dbb415 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -424,15 +424,15 @@ static void print_block_details(struct iinfo *ind, int level, int cur_height,
static void gfs_jindex_print(struct gfs_jindex *ji)
{
- pv(ji, ji_addr, "%"PRIu64, "0x%"PRIx64);
- pv(ji, ji_nsegment, "%"PRIu32, "0x%"PRIx32);
- pv(ji, ji_pad, "%"PRIu32, "0x%"PRIx32);
+ print_it(" ji_addr", "%"PRIu64, "0x%"PRIx64, be64_to_cpu(ji->ji_addr));
+ print_it(" ji_nsegment", "%"PRIu32, "0x%"PRIx32, be32_to_cpu(ji->ji_nsegment));
+ print_it(" ji_pad", "%"PRIu32, "0x%"PRIx32, be32_to_cpu(ji->ji_pad));
}
static int print_gfs_jindex(struct gfs2_inode *dij)
{
int error, start_line;
- struct gfs_jindex ji;
+ struct gfs_jindex *ji;
char jbuf[sizeof(struct gfs_jindex)];
start_line = line;
@@ -444,7 +444,7 @@ static int print_gfs_jindex(struct gfs2_inode *dij)
error = gfs2_readi(dij, (void *)&jbuf,
print_entry_ndx*sizeof(struct gfs_jindex),
sizeof(struct gfs_jindex));
- gfs_jindex_in(&ji, jbuf);
+ ji = (struct gfs_jindex *)jbuf;
if (!error) /* end of file */
break;
if (!termlines ||
@@ -454,13 +454,13 @@ static int print_gfs_jindex(struct gfs2_inode *dij)
if (edit_row[dmode] == print_entry_ndx) {
COLORS_HIGHLIGHT;
strcpy(efield, "ji_addr");
- sprintf(estring, "%"PRIx64, ji.ji_addr);
+ sprintf(estring, "%"PRIx64, be64_to_cpu(ji->ji_addr));
}
print_gfs2("Journal #%d", print_entry_ndx);
eol(0);
if (edit_row[dmode] == print_entry_ndx)
COLORS_NORMAL;
- gfs_jindex_print(&ji);
+ gfs_jindex_print(ji);
last_entry_onscreen[dmode] = print_entry_ndx;
}
}
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index dd509085..adbeb742 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -225,7 +225,6 @@ extern int block_is_statfs_file(uint64_t blk);
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_print(void *lhp);
extern void savemeta(char *out_fn, int saveoption, int gziplevel);
extern void restoremeta(const char *in_fn, const char *out_device,
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index 95fa7c23..1baba02f 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -58,7 +58,6 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size)
if (sbd.gfs1) {
struct gfs2_inode *jiinode;
- struct gfs_jindex ji;
jiinode = lgfs2_inode_get(&sbd, jindex_bh);
if (jiinode == NULL)
@@ -67,9 +66,9 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size)
journal_num * sizeof(struct gfs_jindex),
sizeof(struct gfs_jindex));
if (amtread) {
- gfs_jindex_in(&ji, jbuf);
- jblock = ji.ji_addr;
- *j_size = (uint64_t)ji.ji_nsegment * 0x10;
+ struct gfs_jindex *ji = (struct gfs_jindex *)jbuf;
+ jblock = be64_to_cpu(ji->ji_addr);
+ *j_size = (uint64_t)be32_to_cpu(ji->ji_nsegment) * 0x10;
}
inode_put(&jiinode);
} else {
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 4beff2ca..a99930c2 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -943,7 +943,7 @@ static void get_journal_inode_blocks(void)
struct gfs2_inode *j_inode = NULL;
if (sbd.gfs1) {
- struct gfs_jindex ji;
+ struct gfs_jindex *ji;
char jbuf[sizeof(struct gfs_jindex)];
j_inode = lgfs2_gfs_inode_read(&sbd, sbd.sd_jindex_di.in_addr);
@@ -957,9 +957,9 @@ static void get_journal_inode_blocks(void)
inode_put(&j_inode);
if (!amt)
break;
- gfs_jindex_in(&ji, jbuf);
- jblock = ji.ji_addr;
- gfs1_journal_size = (uint64_t)ji.ji_nsegment * 16;
+ ji = (struct gfs_jindex *)jbuf;
+ jblock = be64_to_cpu(ji->ji_addr);
+ gfs1_journal_size = (uint64_t)be32_to_cpu(ji->ji_nsegment) * 16;
} else {
if (journal + 3 > indirect->ii[0].dirents)
break;
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index bbfd7783..e6744dc2 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -752,7 +752,6 @@ int ji_update(struct gfs2_sbd *sdp)
char journal_name[JOURNAL_NAME_SIZE];
int i, error;
char buf[sizeof(struct gfs_jindex)];
- struct gfs_jindex ji;
if (!ip) {
log_crit(_("Journal index inode not found.\n"));
@@ -778,6 +777,8 @@ int ji_update(struct gfs2_sbd *sdp)
memset(journal_name, 0, sizeof(*journal_name));
for (i = 0; i < sdp->md.journals; i++) {
if (sdp->gfs1) {
+ struct gfs_jindex *ji;
+
error = gfs2_readi(ip,
buf, i * sizeof(struct gfs_jindex),
sizeof(struct gfs_jindex));
@@ -788,8 +789,8 @@ int ji_update(struct gfs2_sbd *sdp)
" journal index file.\n"));
return -1;
}
- gfs_jindex_in(&ji, buf);
- sdp->md.journal[i] = lgfs2_inode_read(sdp, ji.ji_addr);
+ ji = (struct gfs_jindex *)buf;
+ sdp->md.journal[i] = lgfs2_inode_read(sdp, be64_to_cpu(ji->ji_addr));
if (sdp->md.journal[i] == NULL)
return -1;
} else {
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 0869a43e..039a0fd7 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -1468,7 +1468,7 @@ static int reset_journal_seg_size(struct gfs2_sbd *sdp, unsigned int jsize, unsi
static int correct_journal_seg_size(struct gfs2_sbd *sdp)
{
int count;
- struct gfs_jindex ji_0, ji_1;
+ struct gfs_jindex *ji_0, *ji_1;
char buf[sizeof(struct gfs_jindex)];
unsigned int jsize = GFS2_DEFAULT_JSIZE * 1024 * 1024;
@@ -1478,7 +1478,7 @@ static int correct_journal_seg_size(struct gfs2_sbd *sdp)
"Aborting\n"), count);
return -1;
}
- gfs_jindex_in(&ji_0, buf);
+ ji_0 = (struct gfs_jindex *)buf;
if (sdp->md.journals == 1) {
if (sdp->sd_seg_size == 0) {
@@ -1505,11 +1505,11 @@ static int correct_journal_seg_size(struct gfs2_sbd *sdp)
"Aborting\n"), count);
return -1;
}
- gfs_jindex_in(&ji_1, buf);
+ ji_1 = (struct gfs_jindex *)buf;
- jsize = (ji_1.ji_addr - ji_0.ji_addr) * sdp->sd_bsize;
+ jsize = (be64_to_cpu(ji_1->ji_addr) - be64_to_cpu(ji_0->ji_addr)) * sdp->sd_bsize;
out:
- return reset_journal_seg_size(sdp, jsize, ji_0.ji_nsegment);
+ return reset_journal_seg_size(sdp, jsize, be32_to_cpu(ji_0->ji_nsegment));
}
/*
@@ -1521,7 +1521,7 @@ out:
static int reconstruct_journals(struct gfs2_sbd *sdp)
{
int i, count;
- struct gfs_jindex ji;
+ struct gfs_jindex *ji;
char buf[sizeof(struct gfs_jindex)];
/* Ensure that sb_seg_size is valid */
@@ -1537,10 +1537,10 @@ static int reconstruct_journals(struct gfs2_sbd *sdp)
sizeof(struct gfs_jindex));
if (count != sizeof(struct gfs_jindex))
return 0;
- gfs_jindex_in(&ji, buf);
+ ji = (struct gfs_jindex *)buf;
if ((i % 2) == 0)
log_err(".");
- if (reconstruct_single_journal(sdp, i, ji.ji_nsegment))
+ if (reconstruct_single_journal(sdp, i, be32_to_cpu(ji->ji_nsegment)))
return -1;
}
log_err(_("\nJournals cleared.\n"));
diff --git a/gfs2/libgfs2/gfs1.c b/gfs2/libgfs2/gfs1.c
index feb8d22a..272f5572 100644
--- a/gfs2/libgfs2/gfs1.c
+++ b/gfs2/libgfs2/gfs1.c
@@ -22,13 +22,13 @@ static __inline__ int fs_is_jdata(struct gfs2_inode *ip)
return ip->i_flags & GFS2_DIF_JDATA;
}
-static __inline__ uint64_t *
+static __inline__ __be64 *
gfs1_metapointer(char *buf, unsigned int height, struct metapath *mp)
{
unsigned int head_size = (height > 0) ?
sizeof(struct gfs_indirect) : sizeof(struct gfs_dinode);
- return ((uint64_t *)(buf + head_size)) + mp->mp_list[height];
+ return ((__be64 *)(buf + head_size)) + mp->mp_list[height];
}
int is_gfs_dir(struct gfs2_inode *ip)
@@ -42,7 +42,7 @@ void gfs1_lookup_block(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
unsigned int height, struct metapath *mp,
int create, int *new, uint64_t *block)
{
- uint64_t *ptr = gfs1_metapointer(bh->b_data, height, mp);
+ __be64 *ptr = gfs1_metapointer(bh->b_data, height, mp);
if (*ptr) {
*block = be64_to_cpu(*ptr);
@@ -307,19 +307,6 @@ struct gfs2_inode *lgfs2_gfs_inode_read(struct gfs2_sbd *sdp, uint64_t di_addr)
return ip;
}
-/* ------------------------------------------------------------------------ */
-/* gfs_jindex_in - read in a gfs1 jindex structure. */
-/* ------------------------------------------------------------------------ */
-void gfs_jindex_in(struct gfs_jindex *jindex, char *jbuf)
-{
- struct gfs_jindex *str = (struct gfs_jindex *) jbuf;
-
- jindex->ji_addr = be64_to_cpu(str->ji_addr);
- jindex->ji_nsegment = be32_to_cpu(str->ji_nsegment);
- jindex->ji_pad = be32_to_cpu(str->ji_pad);
- memcpy(jindex->ji_reserved, str->ji_reserved, 64);
-}
-
void lgfs2_gfs_rgrp_in(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 e3afa464..c8ec05aa 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -736,7 +736,6 @@ extern int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
unsigned int size);
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 lgfs2_gfs_rgrp_in(const lgfs2_rgrp_t rg, void *buf);
extern void lgfs2_gfs_rgrp_out(const lgfs2_rgrp_t rg, void *buf);
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
[gfs2-utils] 20/27: libgfs2: Fix endianness tagging for
gfs2_bit_search
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 12a282558788405715120e7f8f5a592fa64e196c
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Thu Jun 10 18:17:07 2021 +0100
libgfs2: Fix endianness tagging for gfs2_bit_search
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/libgfs2/fs_bits.c | 21 ++++++++++-----------
1 file changed, 10 insertions(+), 11 deletions(-)
diff --git a/gfs2/libgfs2/fs_bits.c b/gfs2/libgfs2/fs_bits.c
index 72d2b006..8399e486 100644
--- a/gfs2/libgfs2/fs_bits.c
+++ b/gfs2/libgfs2/fs_bits.c
@@ -38,7 +38,7 @@
* single test (on 64 bit arches).
*/
-static inline uint64_t gfs2_bit_search(const unsigned long long *ptr,
+static inline uint64_t gfs2_bit_search(const __le64 *ptr,
unsigned long long mask,
uint8_t state)
{
@@ -67,13 +67,12 @@ static inline uint64_t gfs2_bit_search(const unsigned long long *ptr,
unsigned long gfs2_bitfit(const unsigned char *buf, const unsigned int len,
unsigned long goal, unsigned char state)
{
- unsigned long spoint = (goal << 1) & ((8 * sizeof(unsigned long long)) - 1);
- const unsigned long long *ptr = ((unsigned long long *)buf) + (goal >> 5);
- const unsigned long long *end = (unsigned long long *)
- (buf + ALIGN(len, sizeof(unsigned long long)));
- unsigned long long tmp;
- unsigned long long mask = 0x5555555555555555ULL;
- unsigned long bit;
+ uint32_t spoint = (goal << 1) & ((8 * sizeof(uint64_t)) - 1);
+ const __le64 *ptr = ((__le64 *)buf) + (goal >> 5);
+ const __le64 *end = (__le64 *) (buf + ALIGN(len, sizeof(uint64_t)));
+ uint64_t tmp;
+ uint64_t mask = 0x5555555555555555ULL;
+ uint32_t bit;
if (state > 3)
return 0;
@@ -87,9 +86,9 @@ unsigned long gfs2_bitfit(const unsigned char *buf, const unsigned int len,
ptr++;
}
/* Mask off any bits which are more than len bytes from the start */
- if (ptr == end && (len & (sizeof(unsigned long long) - 1)))
- tmp &= (((unsigned long long)~0) >>
- (64 - 8 * (len & (sizeof(unsigned long long) - 1))));
+ if (ptr == end && (len & (sizeof(uint64_t) - 1)))
+ tmp &= (((uint64_t)~0) >>
+ (64 - 8 * (len & (sizeof(uint64_t) - 1))));
/* Didn't find anything, so return */
if (tmp == 0)
return BFITNOENT;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
[gfs2-utils] 19/27: gfs2l: Sparse fixes
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 90d0e320b603a9104937392638e851a6a6db936e
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Thu Jun 10 18:05:49 2021 +0100
gfs2l: Sparse fixes
Remove a VLA and fix the endianness tagging of some casts.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/libgfs2/gfs2l.c | 15 +++++++++++----
gfs2/libgfs2/lang.c | 6 +++---
2 files changed, 14 insertions(+), 7 deletions(-)
diff --git a/gfs2/libgfs2/gfs2l.c b/gfs2/libgfs2/gfs2l.c
index 15dcd25d..6fc6cd37 100644
--- a/gfs2/libgfs2/gfs2l.c
+++ b/gfs2/libgfs2/gfs2l.c
@@ -28,10 +28,16 @@ static int metastrcmp(const void *a, const void *b)
return strcmp(m1->name, m2->name);
}
-static void print_structs(void)
+static int print_structs(void)
{
- const struct lgfs2_metadata *mlist[lgfs2_metadata_size];
+ const struct lgfs2_metadata **mlist;
int i;
+
+ mlist = calloc(lgfs2_metadata_size, sizeof(struct lgfs2_metadata *));
+ if (mlist == NULL) {
+ perror("Failed to create metadata type array");
+ return 1;
+ }
for (i = 0; i < lgfs2_metadata_size; i++)
mlist[i] = &lgfs2_metadata[i];
@@ -39,6 +45,8 @@ static void print_structs(void)
for (i = 0; i < lgfs2_metadata_size; i++)
if (mlist[i]->mh_type != GFS2_METATYPE_NONE)
printf("%s\n", mlist[i]->name);
+ free(mlist);
+ return 0;
}
static void print_fields(const char *name)
@@ -69,8 +77,7 @@ static int getopts(int argc, char *argv[], struct cmdopts *opts)
}
break;
case 'T':
- print_structs();
- exit(0);
+ exit(print_structs());
case 'F':
print_fields(optarg);
exit(0);
diff --git a/gfs2/libgfs2/lang.c b/gfs2/libgfs2/lang.c
index 740d1a7b..dd46cd21 100644
--- a/gfs2/libgfs2/lang.c
+++ b/gfs2/libgfs2/lang.c
@@ -327,13 +327,13 @@ static int field_print(char *buf, uint64_t addr, const struct lgfs2_metadata *mt
printf("%"PRIu8"\n", *(uint8_t *)fieldp);
break;
case 2:
- printf("%"PRIu16"\n", be16_to_cpu(*(uint16_t *)fieldp));
+ printf("%"PRIu16"\n", be16_to_cpu(*(__be16 *)fieldp));
break;
case 4:
- printf("%"PRIu32"\n", be32_to_cpu(*(uint32_t *)fieldp));
+ printf("%"PRIu32"\n", be32_to_cpu(*(__be32 *)fieldp));
break;
case 8:
- printf("%"PRIu64"\n", be64_to_cpu(*(uint64_t *)fieldp));
+ printf("%"PRIu64"\n", be64_to_cpu(*(__be64 *)fieldp));
break;
default:
// "Reserved" field so just print 0
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
2 years, 10 months
[gfs2-utils] 18/27: libgfs2: Broaden use of struct lgfs2_inum
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 c4a50183a5f5444a8b2e4b11b5254dda4787fd9f
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Thu Jun 10 17:49:50 2021 +0100
libgfs2: Broaden use of struct lgfs2_inum
Now that we have this structure, use it where appropriate. This allows
struct gfs2_inode and others to be tidied up.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/convert/gfs2_convert.c | 27 +++++----
gfs2/edit/extended.c | 18 +++---
gfs2/edit/gfs2hex.c | 3 +-
gfs2/edit/hexedit.c | 46 +++++++--------
gfs2/edit/hexedit.h | 5 +-
gfs2/edit/journal.c | 4 +-
gfs2/edit/savemeta.c | 8 +--
gfs2/fsck/afterpass1_common.c | 4 +-
gfs2/fsck/fs_recovery.c | 6 +-
gfs2/fsck/initialize.c | 120 ++++++++++++++++++-------------------
gfs2/fsck/link.c | 21 +++----
gfs2/fsck/lost_n_found.c | 68 ++++++++++-----------
gfs2/fsck/metawalk.c | 70 +++++++++++-----------
gfs2/fsck/pass1.c | 133 +++++++++++++++++++-----------------------
gfs2/fsck/pass1b.c | 16 ++---
gfs2/fsck/pass2.c | 128 +++++++++++++++++-----------------------
gfs2/fsck/pass3.c | 15 +++--
gfs2/fsck/pass4.c | 14 ++---
gfs2/fsck/rgrepair.c | 2 +-
gfs2/fsck/util.c | 19 +++---
gfs2/fsck/util.h | 2 +-
gfs2/glocktop/glocktop.c | 4 +-
gfs2/libgfs2/fs_ops.c | 56 +++++++++---------
gfs2/libgfs2/gfs1.c | 18 +++---
gfs2/libgfs2/gfs2l.c | 2 +-
gfs2/libgfs2/lang.c | 10 ++--
gfs2/libgfs2/libgfs2.h | 63 +++++++++++---------
gfs2/libgfs2/ondisk.c | 56 +++++-------------
gfs2/libgfs2/structures.c | 8 +--
gfs2/mkfs/main_grow.c | 2 +-
gfs2/mkfs/main_mkfs.c | 11 ++--
tests/nukerg.c | 2 +-
32 files changed, 445 insertions(+), 516 deletions(-)
diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c
index 4439b77a..5228c532 100644
--- a/gfs2/convert/gfs2_convert.c
+++ b/gfs2/convert/gfs2_convert.c
@@ -709,7 +709,7 @@ static int adjust_indirect_blocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip)
if (((isreg||isdir) && ip->i_height <= 1) ||
(isjdata && ip->i_height == 0)) {
if (!issys)
- ip->i_goal_meta = ip->i_addr;
+ ip->i_goal_meta = ip->i_num.in_addr;
return 0; /* nothing to do */
}
@@ -801,7 +801,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_addr;
+ fix->di_addr = ip->i_num.in_addr;
osi_list_add_prev((osi_list_t *)&fix->list,
(osi_list_t *)&cdpns_to_fix);
}
@@ -865,13 +865,13 @@ static int adjust_inode(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh)
return -1;
}
- inode_was_gfs1 = (inode->i_formal_ino == inode->i_addr);
+ inode_was_gfs1 = (inode->i_num.in_formal_ino == inode->i_num.in_addr);
/* Fix the inode number: */
- inode->i_formal_ino = sbp->md.next_inum;
+ inode->i_num.in_formal_ino = sbp->md.next_inum;
/* Fix the inode type: gfs1 uses di_type, gfs2 uses di_mode. */
inode->i_mode &= ~S_IFMT;
- switch (inode->i_pad1) { /* formerly di_type */
+ switch (inode->i_di_type) {
case GFS_FILE_DIR: /* directory */
inode->i_mode |= S_IFDIR;
/* Add this directory to the list of dirs to fix later. */
@@ -882,7 +882,7 @@ 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_addr;
+ fixdir->di_addr = inode->i_num.in_addr;
osi_list_add_prev((osi_list_t *)&fixdir->list,
(osi_list_t *)&dirs_to_fix);
break;
@@ -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_root_dir.no_addr = block;
- sbp->sd_root_dir.no_formal_ino = sbp->md.next_inum;
+ sbp->sd_root_dir.in_addr = block;
+ sbp->sd_root_dir.in_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 */
@@ -1117,8 +1117,8 @@ 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->in_formal_ino = fix_inode->i_formal_ino;
- inum->in_addr = fix_inode->i_addr;
+ inum->in_formal_ino = fix_inode->i_num.in_formal_ino;
+ inum->in_addr = fix_inode->i_num.in_addr;
if (eablk)
*eablk = fix_inode->i_eattr;
@@ -1232,7 +1232,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.in_addr)
- fix->di_paddr = dip->i_addr;
+ fix->di_paddr = dip->i_num.in_addr;
}
}
@@ -2234,7 +2234,7 @@ int main(int argc, char **argv)
/* ---------------------------------------------- */
if (!error) {
/* Add a string notifying inode converstion start? */
- error = inode_renumber(&sb2, sb2.sd_root_dir.no_addr,
+ error = inode_renumber(&sb2, sb2.sd_root_dir.in_addr,
(osi_list_t *)&cdpns_to_fix);
if (error)
log_crit(_("\n%s: Error renumbering inodes.\n"), opts.device);
@@ -2296,8 +2296,7 @@ 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_meta_dir.no_addr = sb2.master_dir->i_addr;
- sb2.sd_meta_dir.no_formal_ino = sb2.master_dir->i_formal_ino;
+ sb2.sd_meta_dir = sb2.master_dir->i_num;
/* Build empty journal index file. */
error = conv_build_jindex(&sb2);
if (error) {
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index 58cc2134..975a514c 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -329,17 +329,17 @@ static int display_leaf(struct iinfo *ind)
line - start_line - 1 ==
edit_row[dmode] - start_row[dmode]) {
COLORS_HIGHLIGHT;
- sprintf(estring, "%"PRIx64, ind->ii[0].dirent[d].inum.addr);
+ sprintf(estring, "%"PRIx64, ind->ii[0].dirent[d].inum.in_addr);
strcpy(edit_fmt, "%llx");
}
}
print_gfs2("%d/%d [%08"PRIX32"] %"PRIu64"/%"PRIu64" (0x%"PRIx64"/0x%"PRIx64") +%"PRIu16": ",
total_dirents, d + 1,
ind->ii[0].dirent[d].hash,
- ind->ii[0].dirent[d].inum.formal_ino,
- ind->ii[0].dirent[d].inum.addr,
- ind->ii[0].dirent[d].inum.formal_ino,
- ind->ii[0].dirent[d].inum.addr,
+ ind->ii[0].dirent[d].inum.in_formal_ino,
+ ind->ii[0].dirent[d].inum.in_addr,
+ ind->ii[0].dirent[d].inum.in_formal_ino,
+ ind->ii[0].dirent[d].inum.in_addr,
ind->ii[0].dirent[d].rahead
);
}
@@ -477,10 +477,10 @@ static int print_gfs2_jindex(void)
for (d = 0; d < indirect->ii[0].dirents; d++) {
if (strncmp(indirect->ii[0].dirent[d].filename, "journal", 7))
continue;
- ip = lgfs2_inode_read(&sbd, indirect->ii[0].dirent[d].inum.addr);
+ ip = lgfs2_inode_read(&sbd, indirect->ii[0].dirent[d].inum.in_addr);
print_gfs2("%s: 0x%-5"PRIx64" %"PRIu64"MB ",
indirect->ii[0].dirent[d].filename,
- indirect->ii[0].dirent[d].inum.addr,
+ indirect->ii[0].dirent[d].inum.in_addr,
ip->i_size / 1048576);
error = lgfs2_find_jhead(ip, &head);
if (error) {
@@ -644,7 +644,7 @@ int display_extended(void)
brelse(tmp_bh);
} else if (block_is_journals(block)) {
if (sbd.gfs1)
- block = sbd.sd_jindex_di.no_addr;
+ block = sbd.sd_jindex_di.in_addr;
else
block = masterblock("jindex");
print_gfs2_jindex();
@@ -655,7 +655,7 @@ int display_extended(void)
return -1;
else if (block_is_rgtree(block)) {
if (sbd.gfs1)
- tmp_bh = bread(&sbd, sbd.sd_rindex_di.no_addr);
+ tmp_bh = bread(&sbd, sbd.sd_rindex_di.in_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 a18df909..d1878639 100644
--- a/gfs2/edit/gfs2hex.c
+++ b/gfs2/edit/gfs2hex.c
@@ -213,8 +213,7 @@ void idirent_in(struct idirent *id, void *dep)
{
struct gfs2_dirent *de = dep;
- id->inum.formal_ino = be64_to_cpu(de->de_inum.no_formal_ino);
- id->inum.addr = be64_to_cpu(de->de_inum.no_addr);
+ lgfs2_inum_in(&id->inum, &de->de_inum);
id->hash = be32_to_cpu(de->de_hash);
id->rec_len = be16_to_cpu(de->de_rec_len);
id->name_len = be16_to_cpu(de->de_name_len);
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index fb643ac3..00f5aa03 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -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_root_dir.no_addr)
+ if (block == sbd.sd_root_dir.in_addr)
print_gfs2("--------------- Root directory ------------------");
- else if (!sbd.gfs1 && block == sbd.sd_meta_dir.no_addr)
+ else if (!sbd.gfs1 && block == sbd.sd_meta_dir.in_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 == sbd.sd_rindex_di.no_addr)
+ if (block == sbd.sd_rindex_di.in_addr)
print_gfs2("---------------- rindex file -------------------");
else if (block == gfs1_quota_di.no_addr)
print_gfs2("---------------- Quota file --------------------");
- else if (block == sbd.sd_jindex_di.no_addr)
+ else if (block == sbd.sd_jindex_di.in_addr)
print_gfs2("--------------- Journal Index ------------------");
else if (block == gfs1_license_di.no_addr)
print_gfs2("--------------- License file -------------------");
@@ -462,7 +462,7 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
int d;
for (d = 2; d < 8; d++) {
- if (block == masterdir.dirent[d].inum.addr) {
+ if (block == masterdir.dirent[d].inum.in_addr) {
if (!strncmp(masterdir.dirent[d].filename, "jindex", 6))
print_gfs2("--------------- Journal Index ------------------");
else if (!strncmp(masterdir.dirent[d].filename, "per_node", 8))
@@ -687,7 +687,7 @@ uint64_t masterblock(const char *fn)
for (d = 2; d < 8; d++)
if (!strncmp(masterdir.dirent[d].filename, fn, strlen(fn)))
- return (masterdir.dirent[d].inum.addr);
+ return (masterdir.dirent[d].inum.in_addr);
return 0;
}
@@ -753,7 +753,7 @@ static uint64_t get_rg_addr(int rgnum)
struct gfs2_inode *riinode;
if (sbd.gfs1)
- gblock = sbd.sd_rindex_di.no_addr;
+ gblock = sbd.sd_rindex_di.in_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 == sbd.sd_rindex_di.no_addr) ||
+ if ((sbd.gfs1 && blk == sbd.sd_rindex_di.in_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 == sbd.sd_jindex_di.no_addr))
+ if ((sbd.gfs1 && blk == sbd.sd_jindex_di.in_addr))
return TRUE;
return FALSE;
}
@@ -936,13 +936,13 @@ static void read_superblock(int fd)
sizeof(uint64_t);
sbd.sd_diptrs = (sbd.sd_bsize - sizeof(struct gfs_dinode)) /
sizeof(uint64_t);
- sbd.md.riinode = lgfs2_inode_read(&sbd, sbd.sd_rindex_di.no_addr);
+ sbd.md.riinode = lgfs2_inode_read(&sbd, sbd.sd_rindex_di.in_addr);
} else {
sbd.sd_inptrs = (sbd.sd_bsize - sizeof(struct gfs2_meta_header)) /
sizeof(uint64_t);
sbd.sd_diptrs = (sbd.sd_bsize - sizeof(struct gfs2_dinode)) /
sizeof(uint64_t);
- sbd.master_dir = lgfs2_inode_read(&sbd, sbd.sd_meta_dir.no_addr);
+ sbd.master_dir = lgfs2_inode_read(&sbd, sbd.sd_meta_dir.in_addr);
if (sbd.master_dir == NULL) {
sbd.md.riinode = NULL;
} else {
@@ -973,7 +973,7 @@ static int read_master_dir(void)
{
ioctl(sbd.device_fd, BLKFLSBUF, 0);
- bh = bread(&sbd, sbd.sd_meta_dir.no_addr);
+ bh = bread(&sbd, sbd.sd_meta_dir.in_addr);
if (bh == NULL)
return 1;
di = (struct gfs2_dinode *)bh->b_data;
@@ -989,12 +989,12 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
if (block == RGLIST_DUMMY_BLOCK) {
if (sbd.gfs1)
- blk = sbd.sd_rindex_di.no_addr;
+ blk = sbd.sd_rindex_di.in_addr;
else
blk = masterblock("rindex");
} else if (block == JOURNALS_DUMMY_BLOCK) {
if (sbd.gfs1)
- blk = sbd.sd_jindex_di.no_addr;
+ blk = sbd.sd_jindex_di.in_addr;
else
blk = masterblock("jindex");
} else
@@ -1029,20 +1029,18 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
lgfs2_sb_in(&sbd, bh->b_data);
memset(indirect, 0, sizeof(struct iinfo));
- ii->block = sbd.sd_meta_dir.no_addr;
+ ii->block = sbd.sd_meta_dir.in_addr;
ii->is_dir = TRUE;
ii->dirents = 2;
id = &ii->dirent[0];
memcpy(id->filename, "root", 4);
- id->inum.formal_ino = sbd.sd_root_dir.no_formal_ino;
- id->inum.addr = sbd.sd_root_dir.no_addr;
+ id->inum = sbd.sd_root_dir;
id->type = DT_DIR;
id = &ii->dirent[1];
memcpy(id->filename, "master", 7);
- id->inum.formal_ino = sbd.sd_meta_dir.no_formal_ino;
- id->inum.addr = sbd.sd_meta_dir.no_addr;
+ id->inum = sbd.sd_meta_dir;
id->type = DT_DIR;
}
else if (gfs2_struct_type == GFS2_METATYPE_DI) {
@@ -1316,19 +1314,19 @@ uint64_t check_keywords(const char *kword)
if (!strcmp(kword, "sb") ||!strcmp(kword, "superblock"))
blk = 0x10 * (4096 / sbd.sd_bsize); /* superblock */
else if (!strcmp(kword, "root") || !strcmp(kword, "rootdir"))
- blk = sbd.sd_root_dir.no_addr;
+ blk = sbd.sd_root_dir.in_addr;
else if (!strcmp(kword, "master")) {
if (sbd.gfs1)
fprintf(stderr, "This is GFS1; there's no master directory.\n");
- else if (!sbd.sd_meta_dir.no_addr) {
+ else if (!sbd.sd_meta_dir.in_addr) {
fprintf(stderr, "GFS2 master directory not found on %s\n", device);
exit(-1);
} else
- blk = sbd.sd_meta_dir.no_addr;
+ blk = sbd.sd_meta_dir.in_addr;
}
else if (!strcmp(kword, "jindex")) {
if (sbd.gfs1)
- blk = sbd.sd_jindex_di.no_addr;
+ blk = sbd.sd_jindex_di.in_addr;
else
blk = masterblock("jindex"); /* journal index */
}
@@ -1344,7 +1342,7 @@ uint64_t check_keywords(const char *kword)
}
else if (!strcmp(kword, "rindex") || !strcmp(kword, "rgindex")) {
if (sbd.gfs1)
- blk = sbd.sd_rindex_di.no_addr;
+ blk = sbd.sd_rindex_di.in_addr;
else
blk = masterblock("rindex");
} else if (!strcmp(kword, "rgs")) {
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index f60d836d..dd509085 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -64,10 +64,7 @@ extern int details;
extern const char *allocdesc[2][5];
struct idirent {
- struct {
- uint64_t formal_ino;
- uint64_t addr;
- } inum;
+ struct lgfs2_inum inum;
uint32_t hash;
uint16_t rec_len;
uint16_t name_len;
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index b3333861..95fa7c23 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -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 = sbd.sd_jindex_di.no_addr;
+ jindex_block = sbd.sd_jindex_di.in_addr;
else
jindex_block = masterblock("jindex");
/* read in the block */
@@ -77,7 +77,7 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size)
if (journal_num > indirect->ii[0].dirents - 2)
return 0;
- jblock = indirect->ii[0].dirent[journal_num + 2].inum.addr;
+ jblock = indirect->ii[0].dirent[journal_num + 2].inum.in_addr;
j_bh = bread(&sbd, jblock);
jdi = (struct gfs2_dinode *)j_bh->b_data;
*j_size = be64_to_cpu(jdi->di_size);
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 09761fe2..4beff2ca 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -278,7 +278,7 @@ static int init_per_node_lookup(void)
for (i = 0; i < indirect_blocks; i++) {
int d;
for (d = 0; d < indirect->ii[i].dirents; d++) {
- int ret = insert_per_node_lookup(indirect->ii[i].dirent[d].inum.addr);
+ int ret = insert_per_node_lookup(indirect->ii[i].dirent[d].inum.in_addr);
if (ret != 0)
return ret;
}
@@ -946,7 +946,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, sbd.sd_jindex_di.no_addr);
+ j_inode = lgfs2_gfs_inode_read(&sbd, sbd.sd_jindex_di.in_addr);
if (j_inode == NULL) {
fprintf(stderr, "Error reading journal inode: %s\n", strerror(errno));
return;
@@ -963,7 +963,7 @@ static void get_journal_inode_blocks(void)
} else {
if (journal + 3 > indirect->ii[0].dirents)
break;
- jblock = indirect->ii[0].dirent[journal + 2].inum.addr;
+ jblock = indirect->ii[0].dirent[journal + 2].inum.in_addr;
}
journal_blocks[journals_found++] = jblock;
}
@@ -1159,7 +1159,7 @@ void savemeta(char *out_fn, int saveoption, int gziplevel)
uint64_t blk;
int j;
- blk = sbd.sd_rindex_di.no_addr;
+ blk = sbd.sd_rindex_di.in_addr;
buf = check_read_block(sbd.device_fd, blk, blk, NULL, NULL);
if (buf != NULL) {
save_buf(&mfd, buf, blk, sbd.sd_bsize);
diff --git a/gfs2/fsck/afterpass1_common.c b/gfs2/fsck/afterpass1_common.c
index c216a5da..9b849316 100644
--- a/gfs2/fsck/afterpass1_common.c
+++ b/gfs2/fsck/afterpass1_common.c
@@ -88,7 +88,7 @@ static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t block,
if (q == GFS2_BLKST_FREE) {
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);
+ btype, block, block, ip->i_num.in_addr, ip->i_num.in_addr);
return META_IS_GOOD;
}
if (find_remove_dup(ip, block, btype, &removed_lastmeta)) { /* a dup */
@@ -101,7 +101,7 @@ static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t 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);
+ ip->i_num.in_addr, ip->i_num.in_addr, block, block);
} else {
check_n_fix_bitmap(ip->i_sbd, ip->i_rgd, block, 0,
GFS2_BLKST_FREE);
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index 9ce6af26..bbfd7783 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -625,7 +625,7 @@ 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 %"PRIu64" (0x%"PRIx64").\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
return META_ERROR; /* Exits check_metatree quicker */
}
return META_IS_GOOD;
@@ -650,7 +650,7 @@ static int rangecheck_jmeta(struct iptr iptr, struct gfs2_buffer_head **bh, int
"indirect block pointer %"PRIu64" (0x%"PRIx64") "
"(points to something that is not an "
"indirect block).\n"),
- ip->i_addr, ip->i_addr, block, block);
+ ip->i_num.in_addr, ip->i_num.in_addr, block, block);
brelse(*bh);
*bh = NULL;
return META_SKIP_FURTHER;
@@ -871,7 +871,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, sdp->sd_jindex_di.no_addr);
+ sdp->md.jiinode = lgfs2_inode_read(sdp, sdp->sd_jindex_di.in_addr);
else
gfs2_lookupi(sdp->master_dir, "jindex", 6, &sdp->md.jiinode);
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 9d661dce..0869a43e 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -464,7 +464,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
}
log_err(_("Trying to rebuild the master directory.\n"));
inum.in_formal_ino = sdp->md.next_inum++;
- inum.in_addr = sdp->sd_meta_dir.no_addr;
+ inum.in_addr = sdp->sd_meta_dir.in_addr;
err = init_dinode(sdp, &bh, &inum, S_IFDIR | 0755, GFS2_DIF_SYSTEM, &inum);
if (err != 0)
return -1;
@@ -477,7 +477,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.jiinode) {
inum.in_formal_ino = sdp->md.next_inum++;
- inum.in_addr = fix_md.jiinode->i_addr;
+ inum.in_addr = fix_md.jiinode->i_num.in_addr;
err = dir_add(sdp->master_dir, "jindex", 6, &inum,
IF2DT(S_IFDIR | 0700));
if (err) {
@@ -495,7 +495,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.pinode) {
inum.in_formal_ino = sdp->md.next_inum++;
- inum.in_addr = fix_md.pinode->i_addr;
+ inum.in_addr = fix_md.pinode->i_num.in_addr;
err = dir_add(sdp->master_dir, "per_node", 8, &inum,
IF2DT(S_IFDIR | 0700));
if (err) {
@@ -515,7 +515,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.inum) {
inum.in_formal_ino = sdp->md.next_inum++;
- inum.in_addr = fix_md.inum->i_addr;
+ inum.in_addr = fix_md.inum->i_num.in_addr;
err = dir_add(sdp->master_dir, "inum", 4, &inum,
IF2DT(S_IFREG | 0600));
if (err) {
@@ -533,7 +533,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.statfs) {
inum.in_formal_ino = sdp->md.next_inum++;
- inum.in_addr = fix_md.statfs->i_addr;
+ inum.in_addr = fix_md.statfs->i_num.in_addr;
err = dir_add(sdp->master_dir, "statfs", 6, &inum,
IF2DT(S_IFREG | 0600));
if (err) {
@@ -551,7 +551,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.riinode) {
inum.in_formal_ino = sdp->md.next_inum++;
- inum.in_addr = fix_md.riinode->i_addr;
+ inum.in_addr = fix_md.riinode->i_num.in_addr;
err = dir_add(sdp->master_dir, "rindex", 6, &inum,
IF2DT(S_IFREG | 0600));
if (err) {
@@ -568,7 +568,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.qinode) {
inum.in_formal_ino = sdp->md.next_inum++;
- inum.in_addr = fix_md.qinode->i_addr;
+ inum.in_addr = fix_md.qinode->i_num.in_addr;
err = dir_add(sdp->master_dir, "quota", 5, &inum,
IF2DT(S_IFREG | 0600));
if (err) {
@@ -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_root_dir.no_addr);
+ sdp->md.rooti = lgfs2_inode_read(sdp, sdp->sd_root_dir.in_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 ((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 ((sdp->sd_license_di.in_addr != sdp->sd_jindex_di.in_addr + 3) ||
+ (sdp->sd_license_di.in_formal_ino != sdp->sd_jindex_di.in_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;
}
- sdp->sd_license_di.no_addr = sdp->sd_license_di.no_formal_ino
- = sdp->sd_jindex_di.no_addr + 3;
+ sdp->sd_license_di.in_addr = sdp->sd_license_di.in_formal_ino
+ = sdp->sd_jindex_di.in_addr + 3;
}
- sdp->md.statfs = lgfs2_inode_read(sdp, sdp->sd_license_di.no_addr);
+ sdp->md.statfs = lgfs2_inode_read(sdp, sdp->sd_license_di.in_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 ((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 ((sdp->sd_quota_di.in_addr != sdp->sd_jindex_di.in_addr + 2) ||
+ (sdp->sd_quota_di.in_formal_ino != sdp->sd_jindex_di.in_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;
}
- sdp->sd_quota_di.no_addr = sdp->sd_quota_di.no_formal_ino
- = sdp->sd_jindex_di.no_addr + 2;
+ sdp->sd_quota_di.in_addr = sdp->sd_quota_di.in_formal_ino
+ = sdp->sd_jindex_di.in_addr + 2;
}
- sdp->md.qinode = lgfs2_inode_read(sdp, sdp->sd_quota_di.no_addr);
+ sdp->md.qinode = lgfs2_inode_read(sdp, sdp->sd_quota_di.in_addr);
if (sdp->md.qinode == NULL) {
log_crit(_("Error reading quota inode: %s\n"), strerror(errno));
goto fail;
@@ -969,7 +969,7 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
*/
static int is_journal_copy(struct gfs2_inode *ip)
{
- if (ip->i_addr == ip->i_bh->b_blocknr)
+ if (ip->i_num.in_addr == ip->i_bh->b_blocknr)
return 0;
return 1; /* journal copy */
}
@@ -990,20 +990,20 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
struct lgfs2_inum inum;
int error;
- if (ip->i_formal_ino == 2) {
- if (sdp->sd_meta_dir.no_addr)
+ if (ip->i_num.in_formal_ino == 2) {
+ if (sdp->sd_meta_dir.in_addr)
return;
log_warn(_("Found system master directory at: 0x%"PRIx64".\n"),
- ip->i_addr);
- sdp->sd_meta_dir.no_addr = ip->i_addr;
+ ip->i_num.in_addr);
+ sdp->sd_meta_dir.in_addr = ip->i_num.in_addr;
return;
}
- if ((!sdp->gfs1 && ip->i_formal_ino == 3) ||
+ if ((!sdp->gfs1 && ip->i_num.in_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"), ip->i_addr);
+ log_warn(_("Found system jindex file at: 0x%"PRIx64"\n"), ip->i_num.in_addr);
fix_md.jiinode = ip;
} else if (!sdp->gfs1 && is_dir(ip, sdp->gfs1)) {
/* Check for a jindex dir entry. Only one system dir has a
@@ -1015,9 +1015,9 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
goto out_discard_ip;
}
fix_md.jiinode = child_ip;
- sdp->sd_meta_dir.no_addr = ip->i_addr;
+ sdp->sd_meta_dir.in_addr = ip->i_num.in_addr;
log_warn(_("Found system master directory at: 0x%"PRIx64"\n"),
- ip->i_addr);
+ ip->i_num.in_addr);
return;
}
@@ -1029,40 +1029,40 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
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_addr);
+ ip->i_num.in_addr);
fix_md.pinode = ip;
error = dir_search(ip, "..", 2, NULL, &inum);
if (!error && inum.in_addr) {
- sdp->sd_meta_dir.no_addr = inum.in_addr;
+ sdp->sd_meta_dir.in_addr = inum.in_addr;
log_warn(_("From per_node's '..' master directory backtracked to: "
"0x%"PRIx64"\n"), inum.in_addr);
}
return;
}
- log_debug(_("Unknown system directory at block 0x%"PRIx64"\n"), ip->i_addr);
+ log_debug(_("Unknown system directory at block 0x%"PRIx64"\n"), ip->i_num.in_addr);
goto out_discard_ip;
} 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"), ip->i_addr);
+ log_warn(_("Found system inum file at: 0x%"PRIx64"\n"), ip->i_num.in_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"), ip->i_addr);
+ log_warn(_("Found system statfs file at: 0x%"PRIx64"\n"), ip->i_num.in_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"), ip->i_addr);
+ log_warn(_("Found system rindex file at: 0x%"PRIx64"\n"), ip->i_num.in_addr);
} else if (!fix_md.qinode && ip->i_size >= 176 &&
- ip->i_formal_ino >= 12 &&
- ip->i_formal_ino <= 100) {
+ ip->i_num.in_formal_ino >= 12 &&
+ ip->i_num.in_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"), ip->i_addr);
+ log_warn(_("Found system quota file at: 0x%"PRIx64"\n"), ip->i_num.in_addr);
} else {
out_discard_ip:
inode_put(&ip);
@@ -1079,23 +1079,23 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
struct lgfs2_inum inum;
int error;
- if (sdp->sd_root_dir.no_addr) /* if we know the root dinode */
+ if (sdp->sd_root_dir.in_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 */
- if (ip->i_formal_ino == 1) {
+ if (ip->i_num.in_formal_ino == 1) {
struct gfs2_buffer_head *root_bh;
- if (ip->i_addr == ip->i_bh->b_blocknr) {
+ if (ip->i_num.in_addr == ip->i_bh->b_blocknr) {
log_warn(_("Found the root directory at: 0x%"PRIx64".\n"),
- ip->i_addr);
- sdp->sd_root_dir.no_addr = ip->i_addr;
+ ip->i_num.in_addr);
+ sdp->sd_root_dir.in_addr = ip->i_num.in_addr;
return;
}
log_warn(_("The root dinode should be at block 0x%"PRIx64" but it "
"seems to be destroyed.\n"),
- ip->i_addr);
+ ip->i_num.in_addr);
log_warn(_("Found a copy of the root directory in a journal "
"at block: 0x%"PRIx64".\n"),
ip->i_bh->b_blocknr);
@@ -1103,7 +1103,7 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
log_err(_("Damaged root dinode not fixed.\n"));
return;
}
- root_bh = bread(sdp, ip->i_addr);
+ root_bh = bread(sdp, ip->i_num.in_addr);
memcpy(root_bh->b_data, ip->i_bh->b_data, sdp->sd_bsize);
bmodified(root_bh);
brelse(root_bh);
@@ -1112,10 +1112,10 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
}
while (ip) {
gfs2_lookupi(ip, "..", 2, &parent_ip);
- if (parent_ip && parent_ip->i_addr == ip->i_addr) {
+ if (parent_ip && parent_ip->i_num.in_addr == ip->i_num.in_addr) {
log_warn(_("Found the root directory at: 0x%"PRIx64"\n"),
- ip->i_addr);
- sdp->sd_root_dir.no_addr = ip->i_addr;
+ ip->i_num.in_addr);
+ sdp->sd_root_dir.in_addr = ip->i_num.in_addr;
inode_put(&parent_ip);
inode_put(&ip);
return;
@@ -1276,22 +1276,22 @@ static int sb_repair(struct gfs2_sbd *sdp)
GFS2_DEFAULT_BSIZE);
if (error)
return error;
- if (!sdp->sd_meta_dir.no_addr) {
+ if (!sdp->sd_meta_dir.in_addr) {
log_err(_("Unable to locate the system master directory.\n"));
return -1;
}
- if (!sdp->sd_root_dir.no_addr) {
+ if (!sdp->sd_root_dir.in_addr) {
log_err(_("Unable to locate the root directory.\n"));
if (possible_root == HIGHEST_BLOCK) {
/* Take advantage of the fact that mkfs.gfs2
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_meta_dir.no_addr - 1;
+ possible_root = sdp->sd_meta_dir.in_addr - 1;
}
log_err(_("Found a possible root at: 0x%llx\n"),
(unsigned long long)possible_root);
- sdp->sd_root_dir.no_addr = possible_root;
+ sdp->sd_root_dir.in_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;
@@ -1319,16 +1319,16 @@ 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)"))) {
log_info(_("Found system master directory at: 0x%"PRIx64"\n"),
- sdp->sd_meta_dir.no_addr);
- sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
+ sdp->sd_meta_dir.in_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.in_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_meta_dir.no_addr;
+ sdp->master_dir->i_num.in_addr = sdp->sd_meta_dir.in_addr;
log_info(_("Found the root directory at: 0x%"PRIx64"\n"),
- sdp->sd_root_dir.no_addr);
- sdp->md.rooti = lgfs2_inode_read(sdp, sdp->sd_root_dir.no_addr);
+ sdp->sd_root_dir.in_addr);
+ sdp->md.rooti = lgfs2_inode_read(sdp, sdp->sd_root_dir.in_addr);
if (sdp->md.rooti == NULL) {
log_crit(_("Error reading root inode: %s\n"), strerror(errno));
return -1;
@@ -1431,7 +1431,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_addr + (seg * sdp->sd_seg_size);
+ lh.lh_first = sdp->md.journal[jnum]->i_num.in_addr + (seg * sdp->sd_seg_size);
lh.lh_sequence = sequence;
bh = bget(sdp, lh.lh_first * sdp->sd_bsize);
@@ -1555,7 +1555,7 @@ static int init_rindex(struct gfs2_sbd *sdp)
int err;
if (sdp->gfs1)
- sdp->md.riinode = lgfs2_inode_read(sdp, sdp->sd_rindex_di.no_addr);
+ sdp->md.riinode = lgfs2_inode_read(sdp, sdp->sd_rindex_di.in_addr);
else
gfs2_lookupi(sdp->master_dir, "rindex", 6, &sdp->md.riinode);
@@ -1644,14 +1644,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_meta_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.in_addr);
if (!sdp->gfs1 &&
(sdp->master_dir->i_magic != GFS2_MAGIC ||
- sdp->master_dir->i_type != GFS2_METATYPE_DI ||
+ sdp->master_dir->i_mh_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_meta_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.in_addr);
if (sdp->master_dir == NULL) {
log_crit(_("Error reading master directory: %s\n"), strerror(errno));
return FSCK_ERROR;
diff --git a/gfs2/fsck/link.c b/gfs2/fsck/link.c
index 43dd6df4..06d4a022 100644
--- a/gfs2/fsck/link.c
+++ b/gfs2/fsck/link.c
@@ -41,29 +41,26 @@ int set_di_nlink(struct gfs2_inode *ip)
struct dir_info *di;
if (is_dir(ip, ip->i_sbd->gfs1)) {
- di = dirtree_find(ip->i_addr);
+ di = dirtree_find(ip->i_num.in_addr);
if (di == NULL) {
log_err(_("Error: directory %"PRIu64" (0x%"PRIx64") is not "
"in the dir_tree (set).\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
return -1;
}
di->di_nlink = ip->i_nlink;
return 0;
}
if (ip->i_nlink == 1) {
- link1_set(&nlink1map, ip->i_addr, 1);
+ link1_set(&nlink1map, ip->i_num.in_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_addr);
+ ii = inodetree_find(ip->i_num.in_addr);
if (!ii) {
- struct lgfs2_inum no = {
- .in_addr = ip->i_addr,
- .in_formal_ino = ip->i_formal_ino
- };
+ struct lgfs2_inum no = ip->i_num;
ii = inodetree_insert(no);
}
if (ii)
@@ -84,7 +81,7 @@ int set_di_nlink(struct gfs2_inode *ip)
int incr_link_count(struct lgfs2_inum no, struct gfs2_inode *ip, const char *why)
{
struct inode_info *ii = NULL;
- uint64_t referenced_from = ip ? ip->i_addr : 0;
+ uint64_t referenced_from = ip ? ip->i_num.in_addr : 0;
struct dir_info *di;
struct gfs2_inode *link_ip;
@@ -115,7 +112,7 @@ int incr_link_count(struct lgfs2_inum no, struct gfs2_inode *ip, const char *why
link_ip = fsck_load_inode(ip->i_sbd, no.in_addr);
/* Check formal ino against dinode before adding to inode tree. */
- if (no.in_formal_ino != link_ip->i_formal_ino) {
+ if (no.in_formal_ino != link_ip->i_num.in_formal_ino) {
fsck_inode_put(&link_ip);
return INCR_LINK_INO_MISMATCH; /* inode mismatch */
}
@@ -135,8 +132,8 @@ int incr_link_count(struct lgfs2_inum no, struct gfs2_inode *ip, const char *why
fsck_inode_put(&link_ip);
return INCR_LINK_BAD;
}
- ii->num.in_addr = link_ip->i_addr;
- ii->num.in_formal_ino = link_ip->i_formal_ino;
+ ii->num.in_addr = link_ip->i_num.in_addr;
+ ii->num.in_formal_ino = link_ip->i_num.in_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 4e543fb1..a9ff85bd 100644
--- a/gfs2/fsck/lost_n_found.c
+++ b/gfs2/fsck/lost_n_found.c
@@ -26,19 +26,19 @@ static void add_dotdot(struct gfs2_inode *ip)
int err;
log_info(_("Adding .. entry to directory %"PRIu64" (0x%"PRIx64") pointing back to lost+found\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
/* If there's a pre-existing .. directory entry, we have to
back out the links. */
- di = dirtree_find(ip->i_addr);
+ di = dirtree_find(ip->i_num.in_addr);
if (di && valid_block(sdp, di->dotdot_parent.in_addr)) {
struct gfs2_inode *dip;
log_debug(_("Directory (0x%"PRIx64") already had a '..' link to (0x%"PRIx64").\n"),
- ip->i_addr, di->dotdot_parent.in_addr);
+ ip->i_num.in_addr, di->dotdot_parent.in_addr);
dip = fsck_load_inode(sdp, di->dotdot_parent.in_addr);
- if (dip->i_formal_ino == di->dotdot_parent.in_formal_ino) {
- decr_link_count(di->dotdot_parent.in_addr, ip->i_addr, sdp->gfs1,
+ if (dip->i_num.in_formal_ino == di->dotdot_parent.in_formal_ino) {
+ decr_link_count(di->dotdot_parent.in_addr, ip->i_num.in_addr, sdp->gfs1,
_(".. unlinked, moving to lost+found"));
if (dip->i_nlink > 0) {
dip->i_nlink--;
@@ -59,9 +59,9 @@ 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_addr, di->dotdot_parent.in_addr,
+ ip->i_num.in_addr, di->dotdot_parent.in_addr,
di->dotdot_parent.in_formal_ino,
- dip->i_formal_ino);
+ dip->i_num.in_formal_ino);
log_debug(_("The parent directory was not changed.\n"));
}
fsck_inode_put(&dip);
@@ -71,18 +71,17 @@ static void add_dotdot(struct gfs2_inode *ip)
log_debug(_("Couldn't find a valid '..' entry "
"for orphan directory (0x%"PRIx64"): "
"'..' = 0x%"PRIx64"\n"),
- ip->i_addr, di->dotdot_parent.in_addr);
+ ip->i_num.in_addr, di->dotdot_parent.in_addr);
else
log_debug(_("Couldn't find directory (0x%"PRIx64") "
"in directory tree.\n"),
- ip->i_addr);
+ ip->i_num.in_addr);
}
if (gfs2_dirent_del(ip, "..", 2))
log_warn( _("add_inode_to_lf: Unable to remove "
"\"..\" directory entry.\n"));
- no.in_addr = lf_dip->i_addr;
- no.in_formal_ino = lf_dip->i_formal_ino;
+ no = lf_dip->i_num;
err = dir_add(ip, "..", 2, &no, (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR));
if (err) {
log_crit(_("Error adding .. directory: %s\n"),
@@ -127,10 +126,7 @@ void make_sure_lf_exists(struct gfs2_inode *ip)
set_di_nlink(sdp->md.rooti);
if (sdp->md.rooti->i_entries > root_entries) {
- struct lgfs2_inum no = {
- .in_addr = lf_dip->i_addr,
- .in_formal_ino = lf_dip->i_formal_ino
- };
+ struct lgfs2_inum no = lf_dip->i_num;
lf_was_created = 1;
/* This is a new lost+found directory, so set its block type
and increment link counts for the directories */
@@ -141,23 +137,23 @@ void make_sure_lf_exists(struct gfs2_inode *ip)
/* 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_addr, _("lost+found dinode"), GFS2_BLKST_DINODE);
+ fsck_bitmap_set(ip, lf_dip->i_num.in_addr, _("lost+found dinode"), GFS2_BLKST_DINODE);
/* root inode links to lost+found */
- no.in_addr = sdp->md.rooti->i_addr;
- no.in_formal_ino = sdp->md.rooti->i_formal_ino;
+ no.in_addr = sdp->md.rooti->i_num.in_addr;
+ no.in_formal_ino = sdp->md.rooti->i_num.in_formal_ino;
incr_link_count(no, lf_dip, _("root"));
/* lost+found link for '.' from itself */
- no.in_addr = lf_dip->i_addr;
- no.in_formal_ino = lf_dip->i_formal_ino;
+ no.in_addr = lf_dip->i_num.in_addr;
+ no.in_formal_ino = lf_dip->i_num.in_formal_ino;
incr_link_count(no, lf_dip, "\".\"");
/* lost+found link for '..' back to root */
incr_link_count(no, sdp->md.rooti, "\"..\"");
if (sdp->gfs1)
- lf_dip->i_pad1 = GFS_FILE_DIR;
+ lf_dip->i_di_type = GFS_FILE_DIR;
}
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);
+ lf_dip->i_num.in_addr, lf_dip->i_num.in_addr);
+ di = dirtree_find(lf_dip->i_num.in_addr);
if (di) {
log_info( _("Marking lost+found inode connected\n"));
di->checked = 1;
@@ -183,7 +179,7 @@ int add_inode_to_lf(struct gfs2_inode *ip){
uint32_t mode;
make_sure_lf_exists(ip);
- if (ip->i_addr == lf_dip->i_addr) {
+ if (ip->i_num.in_addr == lf_dip->i_num.in_addr) {
log_err( _("Trying to add lost+found to itself...skipping"));
return 0;
}
@@ -196,41 +192,40 @@ int add_inode_to_lf(struct gfs2_inode *ip){
switch (mode) {
case S_IFDIR:
add_dotdot(ip);
- sprintf(tmp_name, "lost_dir_%"PRIu64, ip->i_addr);
+ sprintf(tmp_name, "lost_dir_%"PRIu64, ip->i_num.in_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR);
break;
case S_IFREG:
- sprintf(tmp_name, "lost_file_%"PRIu64, ip->i_addr);
+ sprintf(tmp_name, "lost_file_%"PRIu64, ip->i_num.in_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_REG : DT_REG);
break;
case S_IFLNK:
- sprintf(tmp_name, "lost_link_%"PRIu64, ip->i_addr);
+ sprintf(tmp_name, "lost_link_%"PRIu64, ip->i_num.in_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_LNK : DT_LNK);
break;
case S_IFBLK:
- sprintf(tmp_name, "lost_blkdev_%"PRIu64, ip->i_addr);
+ sprintf(tmp_name, "lost_blkdev_%"PRIu64, ip->i_num.in_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_BLK : DT_BLK);
break;
case S_IFCHR:
- sprintf(tmp_name, "lost_chrdev_%"PRIu64, ip->i_addr);
+ sprintf(tmp_name, "lost_chrdev_%"PRIu64, ip->i_num.in_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_CHR : DT_CHR);
break;
case S_IFIFO:
- sprintf(tmp_name, "lost_fifo_%"PRIu64, ip->i_addr);
+ sprintf(tmp_name, "lost_fifo_%"PRIu64, ip->i_num.in_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_FIFO : DT_FIFO);
break;
case S_IFSOCK:
- sprintf(tmp_name, "lost_socket_%"PRIu64, ip->i_addr);
+ sprintf(tmp_name, "lost_socket_%"PRIu64, ip->i_num.in_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_SOCK : DT_SOCK);
break;
default:
- sprintf(tmp_name, "lost_%"PRIu64, ip->i_addr);
+ sprintf(tmp_name, "lost_%"PRIu64, ip->i_num.in_addr);
inode_type = (sdp->gfs1 ? GFS_FILE_REG : DT_REG);
break;
}
- no.in_addr = ip->i_addr;
- no.in_formal_ino = ip->i_formal_ino;
+ no = ip->i_num;
err = dir_add(lf_dip, tmp_name, strlen(tmp_name), &no, inode_type);
if (err) {
log_crit(_("Error adding directory %s: %s\n"),
@@ -242,12 +237,11 @@ int add_inode_to_lf(struct gfs2_inode *ip){
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) {
- no.in_addr = lf_dip->i_addr;
- no.in_formal_ino = lf_dip->i_formal_ino;
+ no = lf_dip->i_num;
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);
+ ip->i_num.in_addr, ip->i_num.in_addr);
lgfs2_dinode_out(lf_dip, lf_dip->i_bh->b_data);
bwrite(lf_dip->i_bh);
return 0;
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 7b5bd873..edeaed88 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -174,7 +174,7 @@ 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_addr == prev_ino_addr) &&
+ if ((ip->i_num.in_addr == prev_ino_addr) &&
(mark == prev_mark) && caller == prev_caller) {
log_info("(0x%"PRIx64") ", bblock);
prevcount++;
@@ -184,13 +184,13 @@ 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_addr == bblock) {
+ } else if (ip->i_num.in_addr == bblock) {
if (prevcount) {
log_info("\n");
prevcount = 0;
}
printf(_("(%s:%d) %s inode found at block (0x%"PRIx64"): marking as '%s'\n"),
- caller, fline, btype, ip->i_addr, block_type_string(mark));
+ caller, fline, btype, ip->i_num.in_addr, block_type_string(mark));
} else {
if (prevcount) {
log_info("\n");
@@ -198,9 +198,9 @@ int _fsck_bitmap_set(struct gfs2_inode *ip, uint64_t bblock,
}
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));
+ caller, fline, ip->i_num.in_addr, btype, bblock, block_type_string(mark));
}
- prev_ino_addr = ip->i_addr;
+ prev_ino_addr = ip->i_num.in_addr;
prev_mark = mark;
prev_caller = caller;
}
@@ -232,24 +232,24 @@ struct gfs2_inode *fsck_system_inode(struct gfs2_sbd *sdp, uint64_t block)
{
int j;
- if (lf_dip && lf_dip->i_addr == block)
+ if (lf_dip && lf_dip->i_num.in_addr == block)
return lf_dip;
if (!sdp->gfs1)
return is_system_inode(sdp, block);
- if (sdp->md.statfs && block == sdp->md.statfs->i_addr)
+ if (sdp->md.statfs && block == sdp->md.statfs->i_num.in_addr)
return sdp->md.statfs;
- if (sdp->md.jiinode && block == sdp->md.jiinode->i_addr)
+ if (sdp->md.jiinode && block == sdp->md.jiinode->i_num.in_addr)
return sdp->md.jiinode;
- if (sdp->md.riinode && block == sdp->md.riinode->i_addr)
+ if (sdp->md.riinode && block == sdp->md.riinode->i_num.in_addr)
return sdp->md.riinode;
- if (sdp->md.qinode && block == sdp->md.qinode->i_addr)
+ if (sdp->md.qinode && block == sdp->md.qinode->i_num.in_addr)
return sdp->md.qinode;
- if (sdp->md.rooti && block == sdp->md.rooti->i_addr)
+ if (sdp->md.rooti && block == sdp->md.rooti->i_num.in_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_addr)
+ block == sdp->md.journal[j]->i_num.in_addr)
return sdp->md.journal[j];
return NULL;
}
@@ -296,7 +296,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_addr);
+ sysip = fsck_system_inode(ip->i_sbd, ip->i_num.in_addr);
if (!sysip)
inode_put(ip_in);
}
@@ -422,7 +422,7 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
"entry %d of directory %"PRIu64" (0x%"PRIx64") "
"is corrupt.\n"),
bh->b_blocknr, bh->b_blocknr, (*count) + 1,
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
if (query( _("Attempt to repair it? (y/n) "))) {
if (dirent_repair(ip, bh, &d, dent, type,
first)) {
@@ -456,7 +456,7 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
"zero in leaf %"PRIu64" (0x%"PRIx64") of "
"directory %"PRIu64" (0x%"PRIx64")!\n"),
bh->b_blocknr, bh->b_blocknr,
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
if (query(_("Attempt to remove it? (y/n) "))) {
dirblk_truncate(ip, prev, bh);
log_err(_("The corrupt directory "
@@ -494,7 +494,7 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
if ((char *)dent + d.dr_rec_len >= bh_end){
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,
+ ip->i_num.in_addr, bh->b_blocknr, ip->i_num.in_addr,
bh->b_blocknr, ip->i_blocks);
break;
}
@@ -529,7 +529,7 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass,
if (!valid_block_ip(ip, *leaf_no)) {
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,
+ *leaf_no, *leaf_no, ip->i_num.in_addr, ip->i_num.in_addr,
lindex, lindex);
msg = _("that is out of range");
goto bad_leaf;
@@ -576,7 +576,7 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass,
if (be32_to_cpu(lfp->lf_header.mh_type) != GFS2_METATYPE_LF) {
log_err(_("Inode %"PRIu64" (0x%"PRIx64") points to bad leaf %"PRIu64
" (0x%"PRIx64").\n"),
- ip->i_addr, ip->i_addr, *leaf_no, *leaf_no);
+ ip->i_num.in_addr, ip->i_num.in_addr, *leaf_no, *leaf_no);
msg = _("that is not a leaf");
goto bad_leaf;
}
@@ -605,7 +605,7 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass,
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"),
- *leaf_no, *leaf_no, ip->i_addr, ip->i_addr,
+ *leaf_no, *leaf_no, ip->i_num.in_addr, ip->i_num.in_addr,
leaf->lf_entries, count);
if (query( _("Update leaf entry count? (y/n) "))) {
leaf->lf_entries = count;
@@ -621,7 +621,7 @@ out:
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"),
- ip->i_addr, ip->i_addr, di_depth, ip->i_depth,
+ ip->i_num.in_addr, ip->i_num.in_addr, di_depth, ip->i_depth,
*ref_count, (*ref_count) << (ip->i_depth - di_depth));
(*ref_count) <<= (ip->i_depth - di_depth);
}
@@ -643,7 +643,7 @@ bad_leaf:
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"),
- ip->i_addr, ip->i_addr, di_depth, ip->i_depth,
+ ip->i_num.in_addr, ip->i_num.in_addr, di_depth, ip->i_depth,
*ref_count, (*ref_count) << (ip->i_depth - di_depth));
(*ref_count) <<= (ip->i_depth - di_depth);
}
@@ -748,7 +748,7 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
}
if (first_ok_leaf == -1) { /* no valid leaf found */
log_err(_("Directory #%"PRIu64" (0x%"PRIx64") has no valid leaf blocks\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
free(tbl);
posix_fadvise(sdp->device_fd, 0, 0, POSIX_FADV_NORMAL);
return 1;
@@ -763,7 +763,7 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
if (!tbl_valid) {
free(tbl);
- log_debug(_("Re-reading 0x%"PRIx64" hash table.\n"), ip->i_addr);
+ log_debug(_("Re-reading 0x%"PRIx64" hash table.\n"), ip->i_num.in_addr);
tbl = get_dir_hash(ip);
if (tbl == NULL) {
perror("get_dir_hash");
@@ -819,19 +819,19 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
} while (1); /* while we have chained leaf blocks */
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);
+ ip->i_num.in_addr, orig_di_depth, ip->i_depth);
tbl_valid = 0;
lindex <<= (ip->i_depth - orig_di_depth);
hsize = (1 << ip->i_depth);
}
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);
+ ip->i_num.in_addr, orig_di_height, ip->i_height);
tbl_valid = 0;
}
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);
+ ip->i_num.in_addr, orig_di_blocks, ip->i_blocks);
tbl_valid = 0;
}
lindex += ref_count;
@@ -927,7 +927,7 @@ static int check_leaf_eattr(struct gfs2_inode *ip, uint64_t block,
log_debug(_("Checking EA leaf block #%"PRIu64" (0x%"PRIx64") for "
"inode #%"PRIu64" (0x%"PRIx64").\n"),
- block, block, ip->i_addr, ip->i_addr);
+ block, block, ip->i_num.in_addr, ip->i_num.in_addr);
error = pass->check_eattr_leaf(ip, block, parent, &bh,
pass->private);
@@ -1064,8 +1064,8 @@ int check_inode_eattr(struct gfs2_inode *ip, struct metawalk_fxns *pass)
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,
+ ip->i_eattr, ip->i_eattr, ip->i_num.in_addr, ip->i_num.in_addr);
+ error = pass->check_eattr_indir(ip, ip->i_eattr, ip->i_num.in_addr,
&indirect_buf, pass->private);
if (!error) {
error = check_indirect_eattr(ip, ip->i_eattr,
@@ -1077,7 +1077,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_eattr, ip->i_addr, pass);
+ error = check_leaf_eattr(ip, ip->i_eattr, ip->i_num.in_addr, pass);
if (error)
stack;
@@ -1405,7 +1405,7 @@ static int metawalk_check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass
/* If there isn't much pointer corruption check the pointers */
log_debug("Processing data blocks for inode 0x%"PRIx64", metadata block 0x%"PRIx64".\n",
- ip->i_addr, metablock);
+ ip->i_num.in_addr, metablock);
for (ptr = ptr_start ; ptr < ptr_end && !fsck_abort; ptr++) {
if (!*ptr)
continue;
@@ -1568,7 +1568,7 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass)
log_notice( _("\rLarge file at %"PRIu64" (0x%"PRIx64") - 100 percent "
"complete. "
"\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
fflush(stdout);
}
undo_metalist:
@@ -1577,7 +1577,7 @@ undo_metalist:
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,
+ ip->i_num.in_addr, ip->i_num.in_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);
@@ -1613,7 +1613,7 @@ undo_metalist:
"block undoing work "
"for inode %"PRIu64" "
"(0x%"PRIx64").\n",
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
rc = 0;
}
}
@@ -1630,7 +1630,7 @@ undo_metalist:
to undo. */
delete_all_dups(ip);
/* Set the dinode as "bad" so it gets deleted */
- fsck_bitmap_set(ip, ip->i_addr, "corrupt", GFS2_BLKST_FREE);
+ fsck_bitmap_set(ip, ip->i_num.in_addr, "corrupt", GFS2_BLKST_FREE);
log_err(_("The corrupt inode was invalidated.\n"));
out:
free_metalist(ip, metalist);
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 9526aed2..8a8ce97c 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -135,7 +135,7 @@ static int pass1_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no,
int pad_size, i;
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);
+ ip->i_num.in_addr, ip->i_num.in_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;
@@ -150,14 +150,14 @@ static int pass1_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no,
pad_size = ref_count * sizeof(uint64_t);
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);
+ ip->i_num.in_addr, ip->i_num.in_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 %"PRIu64" (0x%"PRIx64") patched.\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
out:
*leaf_no = 0;
@@ -200,10 +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_addr, _("itself"), GFS2_BLKST_UNLINKED);
+ fsck_blockmap_set(ip, ip->i_num.in_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);
+ ip->i_num.in_addr, ip->i_num.in_addr);
*is_valid = 0;
return META_IS_GOOD;
}
@@ -246,7 +246,7 @@ static int resuscitate_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (!valid_block_ip(ip, block)) {
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);
+ tmp_name, ip->i_num.in_addr, ip->i_num.in_addr);
return 0;
}
/* If this is a system dinode, we'll handle it later in
@@ -286,7 +286,7 @@ static int p1check_leaf(struct gfs2_inode *ip, uint64_t block, void *private)
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, block, ip->i_num.in_addr, ip->i_num.in_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 :
@@ -321,11 +321,11 @@ 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_addr,
+ fsck_blockmap_set(ip, ip->i_num.in_addr,
_("bad block referencing"), GFS2_BLKST_UNLINKED);
log_debug(_("Bad indirect block (invalid/out of range) "
"found in inode %"PRIu64" (0x%"PRIx64").\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
return META_SKIP_FURTHER;
}
@@ -341,7 +341,7 @@ static int pass1_check_metalist(struct iptr iptr, struct gfs2_buffer_head **bh,
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, block, ip->i_num.in_addr, ip->i_num.in_addr, q,
block_type_string(q));
*was_duplicate = 1;
}
@@ -353,7 +353,7 @@ static int pass1_check_metalist(struct iptr iptr, struct gfs2_buffer_head **bh,
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);
+ ip->i_num.in_addr, ip->i_num.in_addr, block, block, blktypedesc);
if (query(_("Zero the indirect block pointer? (y/n) "))){
*iptr_ptr(iptr) = 0;
bmodified(iptr.ipt_bh);
@@ -400,7 +400,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_addr, _("bad block referencing"), GFS2_BLKST_FREE);
+ fsck_blockmap_set(ip, ip->i_num.in_addr, _("bad block referencing"), GFS2_BLKST_FREE);
return 1;
}
@@ -487,7 +487,7 @@ static int blockmap_set_as_data(struct gfs2_inode *ip, uint64_t 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);
+ ip->i_num.in_addr, ip->i_num.in_addr, block, block);
error = -1;
out:
if (!error)
@@ -506,8 +506,8 @@ static int pass1_check_data(struct gfs2_inode *ip, uint64_t metablock,
if (!valid_block_ip(ip, block)) {
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)
+ ip->i_num.in_addr, ip->i_num.in_addr, block, block);
+ if (metablock == ip->i_num.in_addr)
log_err("\n");
else
log_err(_("from metadata block %"PRIu64" (0x%"PRIx64")\n"),
@@ -515,7 +515,7 @@ static int pass1_check_data(struct gfs2_inode *ip, uint64_t 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_addr, _("bad (out of range) data"), GFS2_BLKST_UNLINKED);
+ fsck_blockmap_set(ip, ip->i_num.in_addr, _("bad (out of range) data"), GFS2_BLKST_UNLINKED);
return -1;
}
bc->data_count++; /* keep the count sane anyway */
@@ -528,8 +528,8 @@ static int pass1_check_data(struct gfs2_inode *ip, uint64_t metablock,
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)
+ block, block, ip->i_num.in_addr, ip->i_num.in_addr);
+ if (metablock == ip->i_num.in_addr)
log_err("\n");
else
log_err(_("from metadata block %llu (0x%llx)\n"),
@@ -608,7 +608,7 @@ static int ask_remove_inode_eattr(struct gfs2_inode *ip,
if (ip->i_eattr == 0)
return 0; /* eattr was removed prior to this call */
log_err(_("Inode %"PRIu64" (0x%"PRIx64") has unrecoverable Extended Attribute errors.\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
if (query( _("Clear all Extended Attributes from the inode? (y/n) "))){
undo_reference(ip, ip->i_eattr, 0, bc);
ip->i_eattr = 0;
@@ -664,7 +664,7 @@ 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 #%"PRIu64" (0x%"PRIx64"): %s"), ip->i_addr, ip->i_addr, emsg);
+ log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): %s"), ip->i_num.in_addr, ip->i_num.in_addr, emsg);
log_err(_(" at block #%"PRIu64" (0x%"PRIx64").\n"), block, block);
}
@@ -733,11 +733,11 @@ 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 #%"PRIu64" (0x%"PRIx64") with extended attribute block\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
if (!leaf_pointer_errors)
return 0;
log_err(_("Inode %"PRIu64" (0x%"PRIx64") has recoverable indirect extended attribute errors.\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
if (query( _("Okay to fix the block count for the inode? (y/n) "))) {
ip->i_blocks = 1 + bc->indir_count + bc->data_count + bc->ea_count;
bmodified(ip->i_bh);
@@ -833,7 +833,7 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, int i,
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);
+ ip->i_num.in_addr, ip->i_num.in_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;
@@ -877,7 +877,7 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,
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);
+ ip->i_num.in_addr, ip->i_num.in_addr, block, block);
fsck_blockmap_set(ip, ip->i_eattr, _("bad (out of range) extended attribute leaf"),
GFS2_BLKST_UNLINKED);
return 1;
@@ -1036,7 +1036,7 @@ static int mark_block_invalid(struct gfs2_inode *ip, uint64_t block,
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);
+ btype, block, block, ip->i_num.in_addr, ip->i_num.in_addr);
return META_IS_GOOD;
}
fsck_blockmap_set(ip, block, btype, GFS2_BLKST_UNLINKED);
@@ -1126,7 +1126,7 @@ static int rangecheck_block(struct gfs2_inode *ip, uint64_t block,
(*bad_pointers)++;
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);
+ btypes[btype], *bad_pointers, ip->i_num.in_addr, ip->i_num.in_addr);
if ((*bad_pointers) <= BAD_POINTER_TOLERANCE)
return META_IS_GOOD;
else
@@ -1138,13 +1138,13 @@ static int rangecheck_block(struct gfs2_inode *ip, uint64_t block,
(*bad_pointers)++;
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);
+ btypes[btype], *bad_pointers, block, block, ip->i_num.in_addr, ip->i_num.in_addr);
if ((*bad_pointers) <= BAD_POINTER_TOLERANCE)
return META_IS_GOOD;
else {
log_debug(_("Inode 0x%"PRIx64" bad pointer tolerance "
"exceeded: block 0x%"PRIx64".\n"),
- ip->i_addr, block);
+ ip->i_num.in_addr, block);
return META_ERROR; /* Exits check_metatree quicker */
}
}
@@ -1248,8 +1248,7 @@ static int set_ip_blockmap(struct gfs2_inode *ip)
default:
return -EINVAL;
}
- no.in_addr = ip->i_addr;
- no.in_formal_ino = ip->i_formal_ino;
+ no = ip->i_num;
if (fsck_blockmap_set(ip, block, ty, GFS2_BLKST_DINODE) ||
(mode == S_IFDIR && !dirtree_insert(no))) {
stack;
@@ -1349,7 +1348,7 @@ static int pass1_check_metatree(struct gfs2_inode *ip,
error = check_metatree(ip, pass);
if (error)
- gfs2_blockmap_set(bl, ip->i_addr, GFS2_BLKST_FREE);
+ gfs2_blockmap_set(bl, ip->i_num.in_addr, GFS2_BLKST_FREE);
return error;
}
@@ -1377,7 +1376,7 @@ static void reprocess_inode(struct gfs2_inode *ip, const char *desc)
alloc_fxns.private = (void *)desc;
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);
+ ip->i_num.in_addr, ip->i_num.in_addr, ip->i_height);
error = pass1_check_metatree(ip, &alloc_fxns);
if (error)
log_err( _("Error %d reprocessing the %s metadata tree.\n"),
@@ -1404,8 +1403,8 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
error = pass1_check_metatree(ip, &rangecheck_fxns);
if (bad_pointers > BAD_POINTER_TOLERANCE) {
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);
+ ip->i_num.in_addr, ip->i_num.in_addr, BAD_POINTER_TOLERANCE);
+ fsck_blockmap_set(ip, ip->i_num.in_addr, _("badly corrupt"), GFS2_BLKST_FREE);
return 0;
}
@@ -1417,7 +1416,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_addr, _("invalid mode"), GFS2_BLKST_FREE);
+ fsck_blockmap_set(ip, ip->i_num.in_addr, _("invalid mode"), GFS2_BLKST_FREE);
return 0;
} else if (error)
goto bad_dinode;
@@ -1454,7 +1453,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
}
log_err(_("Clearing the bad Extended Attributes in "
"inode %"PRIu64" (0x%"PRIx64").\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
eattr_undo_fxns.private = &bc;
check_inode_eattr(ip, &eattr_undo_fxns);
ask_remove_inode_eattr(ip, &bc);
@@ -1465,7 +1464,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
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 +
+ ip->i_num.in_addr, ip->i_num.in_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"),
@@ -1474,10 +1473,10 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
ip->i_blocks = 1 + bc.indir_count + bc.data_count + bc.ea_count;
bmodified(ip->i_bh);
log_err(_("Block count for #%"PRIu64" (0x%"PRIx64") fixed\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
} else
log_err(_("Bad block count for #%"PRIu64" (0x%"PRIx64") not fixed\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
}
return 0;
@@ -1495,15 +1494,15 @@ static void check_i_goal(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
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);
+ ip->i_num.in_addr, ip->i_num.in_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;
+ ip->i_num.in_addr, ip->i_num.in_addr)) {
+ ip->i_goal_meta = ip->i_num.in_addr;
bmodified(ip->i_bh);
} else
log_err(_("Allocation goal block in inode #%"PRIu64
" (0x%"PRIx64") not fixed\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
}
}
@@ -1520,25 +1519,25 @@ static int handle_di(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
ip = fsck_inode_get(sdp, rgd, bh);
- if (ip->i_addr != block) {
+ if (ip->i_num.in_addr != block) {
log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): Bad inode address found: %"PRIu64
" (0x%"PRIx64")\n"),
- block, block, ip->i_addr, ip->i_addr);
+ block, block, ip->i_num.in_addr, ip->i_num.in_addr);
if (query(_("Fix address in inode at block #%"PRIu64" (0x%"PRIx64")? (y/n) "),
block, block)) {
- ip->i_addr = ip->i_formal_ino = block;
+ ip->i_num.in_addr = ip->i_num.in_formal_ino = block;
bmodified(ip->i_bh);
} else
log_err(_("Address in inode at block #%"PRIu64" (0x%"PRIx64" not fixed\n"),
block, block);
}
- if (sdp->gfs1 && ip->i_formal_ino != block) {
+ if (sdp->gfs1 && ip->i_num.in_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);
+ block, block, ip->i_num.in_formal_ino, ip->i_num.in_formal_ino);
if (query(_("Fix formal inode number in inode #%"PRIu64" (0x%"PRIx64")? (y/n) "),
block, block)) {
- ip->i_formal_ino = block;
+ ip->i_num.in_formal_ino = block;
bmodified(ip->i_bh);
} else
log_err( _("Inode number in inode at block #%lld "
@@ -1570,7 +1569,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_addr;
+ iblock = (*sysinode)->i_num.in_addr;
log_info( _("System inode for '%s' is located at block %llu"
" (0x%llx)\n"), filename,
(unsigned long long)iblock,
@@ -1595,14 +1594,11 @@ 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_addr,
+ fsck_blockmap_set(*sysinode, (*sysinode)->i_num.in_addr,
filename, GFS2_BLKST_DINODE);
ds.q = GFS2_BLKST_DINODE;
if (isdir) {
- struct lgfs2_inum no = {
- .in_addr = (*sysinode)->i_addr,
- .in_formal_ino = (*sysinode)->i_formal_ino
- };
+ struct lgfs2_inum no = (*sysinode)->i_num;
dirtree_insert(no);
}
}
@@ -1648,14 +1644,11 @@ static int check_system_inode(struct gfs2_sbd *sdp,
}
if (*sysinode == sdp->md.jiinode)
ji_update(sdp);
- fsck_blockmap_set(*sysinode, (*sysinode)->i_addr,
+ fsck_blockmap_set(*sysinode, (*sysinode)->i_num.in_addr,
filename, GFS2_BLKST_DINODE);
ds.q = GFS2_BLKST_DINODE;
if (isdir) {
- struct lgfs2_inum no = {
- .in_addr = (*sysinode)->i_addr,
- .in_formal_ino = (*sysinode)->i_formal_ino
- };
+ struct lgfs2_inum no = (*sysinode)->i_num;
dirtree_insert(no);
}
} else {
@@ -1714,7 +1707,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_addr,
+ fsck_blockmap_set(sdp->master_dir, sdp->master_dir->i_num.in_addr,
"master", GFS2_BLKST_DINODE);
if (check_system_inode(sdp, &sdp->master_dir, "master",
build_master, 1, NULL, 1)) {
@@ -1724,7 +1717,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_addr,
+ fsck_blockmap_set(sdp->md.rooti, sdp->md.rooti->i_num.in_addr,
"root", GFS2_BLKST_DINODE);
if (check_system_inode(sdp, &sdp->md.rooti, "root", build_root, 1,
NULL, 0)) {
@@ -1773,17 +1766,13 @@ static int check_system_inodes(struct gfs2_sbd *sdp)
/* 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. */
- no.in_addr = sdp->md.statfs->i_addr;
- no.in_formal_ino = sdp->md.statfs->i_formal_ino;
+ no = sdp->md.statfs->i_num;
incr_link_count(no, NULL, _("gfs1 statfs inode"));
- no.in_addr = sdp->md.jiinode->i_addr;
- no.in_formal_ino = sdp->md.jiinode->i_formal_ino;
+ no = sdp->md.jiinode->i_num;
incr_link_count(no, NULL, _("gfs1 jindex inode"));
- no.in_addr = sdp->md.riinode->i_addr;
- no.in_formal_ino = sdp->md.riinode->i_formal_ino;
+ no = sdp->md.riinode->i_num;
incr_link_count(no, NULL, _("gfs1 rindex inode"));
- no.in_addr = sdp->md.qinode->i_addr;
- no.in_formal_ino = sdp->md.qinode->i_formal_ino;
+ no = sdp->md.qinode->i_num;
incr_link_count(no, NULL, _("gfs1 quota inode"));
return 0;
}
@@ -1879,7 +1868,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_addr == block)
+ if (is_inode && ip->i_num.in_addr == block)
add_duplicate_ref(ip, block, REF_IS_INODE, 0,
INODE_VALID);
else
@@ -2127,7 +2116,7 @@ int pass1(struct gfs2_sbd *sdp)
}
/* rgrps and bitmaps don't have bits to represent
their blocks, so don't do this:
- check_n_fix_bitmap(sdp, rgd, rgd->ri.ri_addr + i, 0,
+ check_n_fix_bitmap(sdp, rgd, rgd->ri.ri_num.in_addr + i, 0,
gfs2_meta_rgrp);*/
}
diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c
index 8d702959..dd7653b9 100644
--- a/gfs2/fsck/pass1b.c
+++ b/gfs2/fsck/pass1b.c
@@ -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_addr,
+ fsck_bitmap_set(ip, ip->i_num.in_addr,
_("duplicate referencing bad"),
GFS2_BLKST_FREE);
/* Remove the inode from the inode tree */
- ii = inodetree_find(ip->i_addr);
+ ii = inodetree_find(ip->i_num.in_addr);
if (ii)
inodetree_delete(ii);
- di = dirtree_find(ip->i_addr);
+ di = dirtree_find(ip->i_num.in_addr);
if (di)
dirtree_delete(di);
- link1_set(&nlink1map, ip->i_addr,
+ link1_set(&nlink1map, ip->i_num.in_addr,
0);
/* We delete the dup_handler inode count and
duplicate id BEFORE clearing the metadata,
@@ -424,13 +424,13 @@ static int clone_data(struct gfs2_inode *ip, uint64_t metablock,
if (clonet->first) {
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);
+ ip->i_num.in_addr, ip->i_num.in_addr, block, block);
clonet->first = 0;
return 0;
}
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);
+ ip->i_num.in_addr, ip->i_num.in_addr, block, block);
if (query( _("Okay to clone the duplicated reference? (y/n) "))) {
error = lgfs2_meta_alloc(ip, &cloneblock);
if (!error) {
@@ -493,7 +493,7 @@ static void clone_dup_ref_in_inode(struct gfs2_inode *ip, struct duptree *dt)
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);
+ ip->i_num.in_addr, ip->i_num.in_addr, dt->block, dt->block);
error = check_metatree(ip, &pass1b_fxns_clone);
if (error) {
log_err(_("Error cloning duplicate reference(s) to block %"PRIu64
@@ -875,7 +875,7 @@ static int find_block_ref(struct gfs2_sbd *sdp, uint64_t inode)
/* double-check the meta header just to be sure it's metadata */
if (ip->i_magic != GFS2_MAGIC ||
- ip->i_type != GFS2_METATYPE_DI) {
+ ip->i_mh_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 e06b45a3..98a0a4b8 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -80,7 +80,7 @@ static int set_dotdot_dir(struct gfs2_sbd *sdp, uint64_t childblock, struct lgfs
}
/* Special case for root inode because we set it earlier */
if (di->dotdot_parent.in_addr &&
- sdp->md.rooti->i_addr != di->dinode.in_addr) {
+ sdp->md.rooti->i_num.in_addr != di->dinode.in_addr) {
/* This should never happen */
log_crit(_("Dotdot parent already set for block %"PRIu64" (0x%"PRIx64") "
"-> %"PRIu64" (0x%"PRIx64")\n"),
@@ -183,14 +183,14 @@ 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.in_addr);
- inum.in_addr = dent_ip->i_addr;
- inum.in_formal_ino = dent_ip->i_formal_ino;
+ inum.in_addr = dent_ip->i_num.in_addr;
+ inum.in_formal_ino = dent_ip->i_num.in_formal_ino;
fsck_inode_put(&dent_ip);
}
}
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.in_addr, entry.in_addr, ip->i_addr, ip->i_addr);
+ tmp_name, entry.in_addr, entry.in_addr, ip->i_num.in_addr, ip->i_num.in_addr);
log_err(_("The directory entry has %"PRIu64" (0x%"PRIx64") "
"but the inode has %"PRIu64" (0x%"PRIx64")\n"),
entry.in_formal_ino, entry.in_formal_ino,
@@ -206,20 +206,17 @@ 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.in_addr);
error = dir_search(child_ip, "..", 2, NULL, &childs_dotdot);
- if (!error && childs_dotdot.in_addr == ip->i_addr) {
+ if (!error && childs_dotdot.in_addr == ip->i_num.in_addr) {
log_err( _("The entry points to another directory with intact "
"linkage.\n"));
if (query( _("Fix the bad directory entry? (y/n) "))) {
- struct lgfs2_inum no;
log_err( _("Fixing the corrupt directory entry.\n"));
entry.in_formal_ino = inum.in_formal_ino;
d->dr_inum.in_formal_ino = entry.in_formal_ino;
lgfs2_dirent_out(d, dent);
bmodified(bh);
incr_link_count(entry, ip, _("fixed reference"));
- no.in_addr = ip->i_addr;
- no.in_formal_ino = ip->i_formal_ino;
- set_parent_dir(sdp, entry, no);
+ set_parent_dir(sdp, entry, ip->i_num);
} else {
log_err( _("Directory entry not fixed.\n"));
}
@@ -274,7 +271,7 @@ static int check_leaf_depth(struct gfs2_inode *ip, uint64_t leaf_no,
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,
+ leaf_no, leaf_no, ip->i_num.in_addr, ip->i_num.in_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"));
@@ -362,7 +359,7 @@ static int wrong_leaf(struct gfs2_inode *ip, struct lgfs2_inum *entry,
}
if (lgfs2_get_leaf_ptr(ip, hash_index, &real_leaf)) {
log_err(_("Could not read leaf %d in dinode %"PRIu64": %s\n"), hash_index,
- ip->i_addr, strerror(errno));
+ ip->i_num.in_addr, strerror(errno));
}
if (real_leaf != planned_leaf) {
log_err(_("The planned leaf was split. The new leaf "
@@ -387,11 +384,7 @@ static int wrong_leaf(struct gfs2_inode *ip, struct lgfs2_inum *entry,
to nuke the dent from this leaf when we return, but we
still need to do the "good dent" accounting. */
if (d->dr_type == (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR)) {
- struct lgfs2_inum no = {
- .in_addr = ip->i_addr,
- .in_formal_ino = ip->i_formal_ino
- };
- error = set_parent_dir(sdp, d->dr_inum, no);
+ error = set_parent_dir(sdp, d->dr_inum, ip->i_num);
if (error > 0)
/* This is a bit of a kludge, but returning 0
in this case causes the caller to go through
@@ -447,7 +440,7 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (!valid_block_ip(ip, entry->in_addr)) {
log_err(_("Block # referenced by directory entry %s in inode %"PRIu64
" (0x%"PRIx64") is invalid\n"),
- tmp_name, ip->i_addr, ip->i_addr);
+ tmp_name, ip->i_num.in_addr, ip->i_num.in_addr);
if (query( _("Clear directory entry to out of range block? (y/n) "))) {
return 1;
} else {
@@ -518,7 +511,7 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (*q != GFS2_BLKST_DINODE) {
log_err(_("Directory entry '%s' referencing inode %"PRIu64" (0x%"PRIx64") "
"in dir inode %"PRIu64" (0x%"PRIx64") block type %d: %s.\n"),
- tmp_name, entry->in_addr, entry->in_addr, ip->i_addr, ip->i_addr,
+ tmp_name, entry->in_addr, entry->in_addr, ip->i_num.in_addr, ip->i_num.in_addr,
*q, *q == GFS2_BLKST_FREE ?
_("was previously marked invalid") :
_("was deleted or is not an inode"));
@@ -551,7 +544,7 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (error < 0) {
log_err(_("Error: directory entry type is incompatible with block type at block %"PRIu64
" (0x%"PRIx64") in directory inode %"PRIu64" (0x%"PRIx64").\n"),
- entry->in_addr, entry->in_addr, ip->i_addr, ip->i_addr);
+ entry->in_addr, entry->in_addr, ip->i_num.in_addr, ip->i_num.in_addr);
log_err( _("Directory entry type is %d, block type is %d.\n"),
d->dr_type, *q);
stack;
@@ -567,7 +560,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_addr == entry->in_addr)
+ if (ip->i_num.in_addr == entry->in_addr)
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry->in_addr);
@@ -595,7 +588,7 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (inum.in_formal_ino != entry->in_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->in_addr, entry->in_addr, ip->i_addr, ip->i_addr);
+ tmp_name, entry->in_addr, entry->in_addr, ip->i_num.in_addr, ip->i_num.in_addr);
log_err(_("The directory entry has %"PRIu64" (0x%"PRIx64") but the "
"inode has %"PRIu64" (0x%"PRIx64")\n"),
entry->in_formal_ino, entry->in_formal_ino,
@@ -614,7 +607,7 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
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,
- entry->in_addr, entry->in_addr, ip->i_addr, ip->i_addr);
+ entry->in_addr, entry->in_addr, ip->i_num.in_addr, ip->i_num.in_addr);
brelse(tbh);
return 1;
}
@@ -649,7 +642,7 @@ static int dirref_find(struct gfs2_inode *ip, struct gfs2_dirent *dent,
}
log_err(_("The original reference to inode %"PRIu64" (0x%"PRIx64") from "
"directory %"PRIu64" (0x%"PRIx64") has the wrong 'formal' inode "
- "number.\n"), entry->in_addr, entry->in_addr, ip->i_addr, ip->i_addr);
+ "number.\n"), entry->in_addr, entry->in_addr, ip->i_num.in_addr, ip->i_num.in_addr);
memset(fn, 0, sizeof(fn));
if (de->dr_name_len < MAX_FILENAME)
strncpy(fn, filename, de->dr_name_len);
@@ -663,7 +656,7 @@ 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->in_addr, ip->i_addr, ip->i_sbd->gfs1,
+ decr_link_count(entry->in_addr, ip->i_num.in_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);
@@ -735,7 +728,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 lgfs2_inum entry, no;
+ struct lgfs2_inum entry;
struct dir_status *ds = (struct dir_status *) priv;
int error;
struct gfs2_inode *entry_ip = NULL;
@@ -763,18 +756,18 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (!strcmp(".", tmp_name)) {
log_debug(_("Found . dentry in directory %"PRIu64" (0x%"PRIx64")\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
if (ds->dotdir) {
log_err(_("Already found '.' entry in directory %"PRIu64" (0x%"PRIx64")\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_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_addr == entry.in_addr)
+ if (ip->i_num.in_addr == entry.in_addr)
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.in_addr);
@@ -788,19 +781,19 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
* location */
/* check that '.' refers to this inode */
- if (entry.in_addr != ip->i_addr) {
+ if (entry.in_addr != ip->i_num.in_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.in_addr, entry.in_addr, entry.in_addr, entry.in_addr,
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_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_addr == entry.in_addr)
+ if (ip->i_num.in_addr == entry.in_addr)
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.in_addr);
@@ -815,10 +808,10 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
}
if (!strcmp("..", tmp_name)) {
log_debug(_("Found '..' dentry in directory %"PRIu64" (0x%"PRIx64")\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
if (ds->dotdotdir) {
log_err(_("Already had a '..' entry in directory %"PRIu64" (0x%"PRIx64")\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
if (!query( _("Clear duplicate '..' entry? (y/n) "))) {
log_err( _("Duplicate '..' entry remains\n"));
/* FIXME: Should we continue on here
@@ -827,7 +820,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
goto dentry_is_valid;
}
- if (ip->i_addr == entry.in_addr)
+ if (ip->i_num.in_addr == entry.in_addr)
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.in_addr);
@@ -840,12 +833,12 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
if (!isdir) {
log_err(_("Found '..' entry in directory %"PRIu64" (0x%"PRIx64") "
"pointing to something that's not a directory"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
if (!query( _("Clear bad '..' directory entry? (y/n) "))) {
log_err( _("Bad '..' directory entry remains\n"));
goto dentry_is_valid;
}
- if (ip->i_addr == entry.in_addr)
+ if (ip->i_num.in_addr == entry.in_addr)
entry_ip = ip;
else
entry_ip = fsck_load_inode(sdp, entry.in_addr);
@@ -860,7 +853,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_addr, entry)) {
+ if (set_dotdot_dir(sdp, ip->i_num.in_addr, entry)) {
stack;
return -1;
}
@@ -892,9 +885,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,
}
/*log_debug( _("Found plain directory dentry\n"));*/
- no.in_addr = ip->i_addr;
- no.in_formal_ino = ip->i_formal_ino;
- error = set_parent_dir(sdp, entry, no);
+ error = set_parent_dir(sdp, entry, ip->i_num);
if (error > 0) {
log_err(_("%s: Hard link to block %"PRIu64" (0x%"PRIx64") detected.\n"),
tmp_name, entry.in_addr, entry.in_addr);
@@ -962,7 +953,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
if ((1 << factor) != num_copies) {
log_err(_("Program error: num_copies not a factor of 2.\n"));
log_err(_("num_copies=%d, dinode = %"PRIu64" (0x%"PRIx64")\n"),
- num_copies, dip->i_addr, dip->i_addr);
+ num_copies, dip->i_num.in_addr, dip->i_num.in_addr);
log_err(_("lindex = %d (0x%x)\n"), start_lindex, start_lindex);
stack;
free(padbuf);
@@ -1009,7 +1000,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
pad_size = num_copies * sizeof(uint64_t);
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,
+ dip->i_num.in_addr, dip->i_num.in_addr,
start_lindex, (unsigned long)pad_size / sizeof(uint64_t));
if (dip->i_sbd->gfs1)
count = gfs1_writei(dip, padbuf, start_lindex *
@@ -1042,7 +1033,7 @@ static void pad_with_leafblks(struct gfs2_inode *ip, uint64_t *tbl,
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);
+ ip->i_num.in_addr, ip->i_num.in_addr, lindex, lindex, len);
while (len) {
new_len = 1;
/* Determine the next factor of 2 down from extras. We can't
@@ -1153,10 +1144,7 @@ static int lost_leaf(struct gfs2_inode *ip, uint64_t *tbl, uint64_t leafno,
/* If it's a directory, lost+found is
back-linked to it via .. */
if (isdir) {
- struct lgfs2_inum no = {
- .in_addr = lf_dip->i_addr,
- .in_formal_ino = lf_dip->i_formal_ino
- };
+ struct lgfs2_inum no = lf_dip->i_num;
incr_link_count(no, NULL, _("to lost+found"));
}
log_err(_("Relocated \"%s\", block %"PRIu64" (0x%"PRIx64") to lost+found.\n"),
@@ -1233,7 +1221,7 @@ static int pass2_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no,
uint64_t bn = 0;
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);
+ ip->i_num.in_addr, ip->i_num.in_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;
@@ -1258,7 +1246,7 @@ static int pass2_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no,
ref_count -= refs;
}
log_err(_("Directory Inode %"PRIu64" (0x%"PRIx64") repaired.\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
out:
*leaf_no = bn;
return new_leaf_blks;
@@ -1320,7 +1308,7 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize,
*proper_len = len;
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);
+ ip->i_num.in_addr, ip->i_num.in_addr, lindex, len, leafblk, leafblk);
if (!query( _("Fix the hash table? (y/n) "))) {
log_err(_("Hash table not fixed.\n"));
return 0;
@@ -1512,7 +1500,7 @@ static int check_hash_tbl_dups(struct gfs2_inode *ip, uint64_t *tbl,
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"),
- ip->i_addr, ip->i_addr, leafblk, leafblk, lindex, lindex,
+ ip->i_num.in_addr, ip->i_num.in_addr, leafblk, leafblk, lindex, lindex,
len, l, l, len2);
/* See which set of references is valid: the one passed in
@@ -1656,7 +1644,7 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
log_err(_("Dinode %"PRIu64" (0x%"PRIx64") has bad leaf pointers "
"at offset %d for %d\n"),
- ip->i_addr, ip->i_addr, lindex, len);
+ ip->i_num.in_addr, ip->i_num.in_addr, lindex, len);
if (!query( _("Fix the hash table? (y/n) "))) {
log_err(_("Hash table not fixed.\n"));
lindex += len;
@@ -1742,7 +1730,7 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl,
log_err(_("Dinode %"PRIu64" (0x%"PRIx64") has a hash table "
"inconsistency at index %d (0x%x) for %d\n"),
- ip->i_addr, ip->i_addr,
+ ip->i_num.in_addr, ip->i_num.in_addr,
i, i, len);
if (!query( _("Fix the hash table? (y/n) "))) {
log_err(_("Hash table not fixed.\n"));
@@ -1899,7 +1887,7 @@ build_it:
log_err(_("Error rebuilding %s.\n"), fn);
return -1;
}
- fsck_bitmap_set(ip, ip->i_addr, fn, GFS2_BLKST_DINODE);
+ fsck_bitmap_set(ip, ip->i_num.in_addr, fn, GFS2_BLKST_DINODE);
log_err(_("System file %s rebuilt.\n"), fn);
goto out_good;
}
@@ -1921,7 +1909,7 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
return -1;
}
- iblock = sysinode->i_addr;
+ iblock = sysinode->i_num.in_addr;
ds.q = bitmap_type(sysinode->i_sbd, iblock);
pass2_fxns.private = (void *) &ds;
@@ -1950,10 +1938,7 @@ 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 lgfs2_inum no = {
- .in_addr = sysinode->i_addr,
- .in_formal_ino = sysinode->i_formal_ino
- };
+ struct lgfs2_inum no = sysinode->i_num;
log_warn( _("Adding '.' entry\n"));
error = dir_add(sysinode, ".", 1, &no,
(sysinode->i_sbd->gfs1 ? GFS_FILE_DIR : DT_DIR));
@@ -1970,16 +1955,16 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname,
}
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,
+ dirname, sysinode->i_num.in_addr, sysinode->i_num.in_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)) {
+ dirname, sysinode->i_num.in_addr, sysinode->i_num.in_addr)) {
sysinode->i_entries = ds.entry_count;
bmodified(sysinode->i_bh);
log_warn( _("Entries updated\n"));
} else {
log_err(_("Entries for inode %"PRIu64" (0x%"PRIx64") left out of sync\n"),
- sysinode->i_addr, sysinode->i_addr);
+ sysinode->i_num.in_addr, sysinode->i_num.in_addr);
}
}
error = 0;
@@ -2009,20 +1994,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_addr)
+ if (block == sdp->md.rooti->i_num.in_addr)
return 1;
if (sdp->gfs1)
return 0;
- if (block == sdp->md.jiinode->i_addr ||
- block == sdp->md.pinode->i_addr ||
- block == sdp->master_dir->i_addr)
+ if (block == sdp->md.jiinode->i_num.in_addr ||
+ block == sdp->md.pinode->i_num.in_addr ||
+ block == sdp->master_dir->i_num.in_addr)
return 1;
return 0;
}
static int pass2_check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
{
- uint64_t dirblk = ip->i_addr;
+ uint64_t dirblk = ip->i_num.in_addr;
struct dir_status ds = {0};
int error;
@@ -2075,10 +2060,7 @@ 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) "))) {
- struct lgfs2_inum no = {
- .in_addr = ip->i_addr,
- .in_formal_ino = ip->i_formal_ino
- };
+ struct lgfs2_inum no = ip->i_num;
error = dir_add(ip, ".", 1, &no,
(sdp->gfs1 ? GFS_FILE_DIR : DT_DIR));
if (error) {
@@ -2097,7 +2079,7 @@ static int pass2_check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip)
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);
+ ip->i_entries, ds.entry_count, ip->i_num.in_addr, ip->i_num.in_addr);
if (query(_("Fix the entry count? (y/n) "))) {
ip->i_entries = ds.entry_count;
bmodified(ip->i_bh);
@@ -2172,7 +2154,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_addr)) {
+ if (lf_was_created && (dirblk == lf_dip->i_num.in_addr)) {
log_debug(_("Pass2 skipping the new lost+found.\n"));
continue;
}
diff --git a/gfs2/fsck/pass3.c b/gfs2/fsck/pass3.c
index f96881f5..fa2fd388 100644
--- a/gfs2/fsck/pass3.c
+++ b/gfs2/fsck/pass3.c
@@ -40,8 +40,7 @@ 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 \"..\""));
- no.in_addr = pip->i_addr;
- no.in_formal_ino = pip->i_formal_ino;
+ no = pip->i_num;
err = dir_add(ip, filename, filename_len, &no,
(sdp->gfs1 ? GFS_FILE_DIR : DT_DIR));
if (err) {
@@ -166,38 +165,38 @@ int pass3(struct gfs2_sbd *sdp)
struct gfs2_inode *ip;
int q;
- di = dirtree_find(sdp->md.rooti->i_addr);
+ di = dirtree_find(sdp->md.rooti->i_num.in_addr);
if (di) {
log_info( _("Marking root inode connected\n"));
di->checked = 1;
}
if (sdp->gfs1) {
- di = dirtree_find(sdp->md.statfs->i_addr);
+ di = dirtree_find(sdp->md.statfs->i_num.in_addr);
if (di) {
log_info( _("Marking GFS1 statfs file inode "
"connected\n"));
di->checked = 1;
}
- di = dirtree_find(sdp->md.jiinode->i_addr);
+ di = dirtree_find(sdp->md.jiinode->i_num.in_addr);
if (di) {
log_info( _("Marking GFS1 jindex file inode "
"connected\n"));
di->checked = 1;
}
- di = dirtree_find(sdp->md.riinode->i_addr);
+ di = dirtree_find(sdp->md.riinode->i_num.in_addr);
if (di) {
log_info( _("Marking GFS1 rindex file inode "
"connected\n"));
di->checked = 1;
}
- di = dirtree_find(sdp->md.qinode->i_addr);
+ di = dirtree_find(sdp->md.qinode->i_num.in_addr);
if (di) {
log_info( _("Marking GFS1 quota file inode "
"connected\n"));
di->checked = 1;
}
} else {
- di = dirtree_find(sdp->master_dir->i_addr);
+ di = dirtree_find(sdp->master_dir->i_num.in_addr);
if (di) {
log_info( _("Marking master directory inode "
"connected\n"));
diff --git a/gfs2/fsck/pass4.c b/gfs2/fsck/pass4.c
index 4deac26c..0891e143 100644
--- a/gfs2/fsck/pass4.c
+++ b/gfs2/fsck/pass4.c
@@ -29,14 +29,14 @@ struct metawalk_fxns pass4_fxns_delete = {
static int fix_link_count(uint32_t counted_links, struct gfs2_inode *ip)
{
log_info(_("Fixing inode link count (%d->%d) for %"PRIu64" (0x%"PRIx64") \n"),
- ip->i_nlink, counted_links, ip->i_addr, ip->i_addr);
+ ip->i_nlink, counted_links, ip->i_num.in_addr, ip->i_num.in_addr);
if (ip->i_nlink == counted_links)
return 0;
ip->i_nlink = counted_links;
bmodified(ip->i_bh);
log_debug(_("Changing inode %"PRIu64" (0x%"PRIx64") to have %u links\n"),
- ip->i_addr, ip->i_addr, counted_links);
+ ip->i_num.in_addr, ip->i_num.in_addr, counted_links);
return 0;
}
@@ -161,7 +161,7 @@ static int adjust_lf_links(int lf_addition)
if (!lf_addition)
return 0;
- if (!(lf_di = dirtree_find(lf_dip->i_addr))) {
+ if (!(lf_di = dirtree_find(lf_dip->i_num.in_addr))) {
log_crit(_("Unable to find lost+found inode in "
"inode_hash!!\n"));
return -1;
@@ -186,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->num.in_addr == sdp->md.riinode->i_addr) ||
- (ii->num.in_addr == sdp->md.qinode->i_addr) ||
- (ii->num.in_addr == sdp->md.statfs->i_addr)))
+ ((ii->num.in_addr == sdp->md.riinode->i_num.in_addr) ||
+ (ii->num.in_addr == sdp->md.qinode->i_num.in_addr) ||
+ (ii->num.in_addr == sdp->md.statfs->i_num.in_addr)))
continue;
if (ii->counted_links == 0) {
if (handle_unlinked(sdp, ii->num.in_addr,
@@ -222,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.in_addr == sdp->md.jiinode->i_addr)
+ di->dinode.in_addr == sdp->md.jiinode->i_num.in_addr)
continue;
if (di->counted_links == 0) {
if (handle_unlinked(sdp, di->dinode.in_addr,
diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c
index 9d165083..da62cc47 100644
--- a/gfs2/fsck/rgrepair.c
+++ b/gfs2/fsck/rgrepair.c
@@ -59,7 +59,7 @@ static void find_journaled_rgs(struct gfs2_sbd *sdp)
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%"PRIx64".\n"),
- j, ip->i_addr);
+ j, ip->i_num.in_addr);
jblocks = ip->i_size / sdp->sd_bsize;
false_count = 0;
for (b = 0; b < jblocks; b++) {
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index 29b3ce81..762266df 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -51,7 +51,8 @@ void big_file_comfort(struct gfs2_inode *ip, uint64_t blks_checked)
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);
+ chksize, human_abbrev[cs], fsize, human_abbrev[i], ip->i_num.in_addr,
+ ip->i_num.in_addr, percent);
fflush(stdout);
}
@@ -277,13 +278,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_addr)
+ if (id->block_no == ip->i_num.in_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_addr)
+ if (id->block_no == ip->i_num.in_addr)
return id;
}
return NULL;
@@ -363,7 +364,7 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block,
(unsigned long long)block);
log_info(_("I'll consider the reference from inode %"PRIu64
" (0x%"PRIx64") the first reference.\n"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
dt->dup_flags |= DUPFLAG_REF1_IS_DUPL;
dt->refs++;
}
@@ -388,8 +389,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_addr;
- q = bitmap_type(ip->i_sbd, ip->i_addr);
+ id->block_no = ip->i_num.in_addr;
+ q = bitmap_type(ip->i_sbd, ip->i_num.in_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)
@@ -413,7 +414,7 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block,
"as %s in %s inode #%"PRIu64" (0x%"PRIx64")\n"),
id->dup_count, block, block, reftypes[reftype],
inode_valid ? _("valid") : _("invalid"),
- ip->i_addr, ip->i_addr);
+ ip->i_num.in_addr, ip->i_num.in_addr);
if (first)
log_info( _("This is the original reference.\n"));
else {
@@ -609,14 +610,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_addr) {
+ if (id->block_no == ip->i_num.in_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_addr) {
+ if (id->block_no == ip->i_num.in_addr) {
dup_listent_delete(dt, id);
found = 1;
}
diff --git a/gfs2/fsck/util.h b/gfs2/fsck/util.h
index 182868a6..d56bb24b 100644
--- a/gfs2/fsck/util.h
+++ b/gfs2/fsck/util.h
@@ -95,7 +95,7 @@ static inline int is_dir(struct gfs2_inode *ip, int gfs1)
static inline uint32_t gfs_to_gfs2_mode(struct gfs2_inode *ip)
{
- uint16_t gfs1mode = ip->i_pad1;
+ uint16_t gfs1mode = ip->i_di_type;
switch (gfs1mode) {
case GFS_FILE_DIR:
diff --git a/gfs2/glocktop/glocktop.c b/gfs2/glocktop/glocktop.c
index e7282517..437ee0ba 100644
--- a/gfs2/glocktop/glocktop.c
+++ b/gfs2/glocktop/glocktop.c
@@ -635,13 +635,13 @@ 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_addr == parent->i_addr) {
+ if (ip->i_num.in_addr == parent->i_num.in_addr) {
inode_put(&parent);
break;
}
inode_put(&ip);
ip = parent;
- dirarray[subdepth++] = parent->i_addr;
+ dirarray[subdepth++] = parent->i_num.in_addr;
}
display_filename(fd, block, dirarray, subdepth);
} else if (S_ISREG(ip->i_mode)) {
diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index dae6d1b7..e533b9de 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
@@ -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_addr)
+ if (sdp->md.inum && block == sdp->md.inum->i_num.in_addr)
return sdp->md.inum;
- if (sdp->md.statfs && block == sdp->md.statfs->i_addr)
+ if (sdp->md.statfs && block == sdp->md.statfs->i_num.in_addr)
return sdp->md.statfs;
- if (sdp->md.jiinode && block == sdp->md.jiinode->i_addr)
+ if (sdp->md.jiinode && block == sdp->md.jiinode->i_num.in_addr)
return sdp->md.jiinode;
- if (sdp->md.riinode && block == sdp->md.riinode->i_addr)
+ if (sdp->md.riinode && block == sdp->md.riinode->i_num.in_addr)
return sdp->md.riinode;
- if (sdp->md.qinode && block == sdp->md.qinode->i_addr)
+ if (sdp->md.qinode && block == sdp->md.qinode->i_num.in_addr)
return sdp->md.qinode;
- if (sdp->md.pinode && block == sdp->md.pinode->i_addr)
+ if (sdp->md.pinode && block == sdp->md.pinode->i_num.in_addr)
return sdp->md.pinode;
- if (sdp->md.rooti && block == sdp->md.rooti->i_addr)
+ if (sdp->md.rooti && block == sdp->md.rooti->i_num.in_addr)
return sdp->md.rooti;
- if (sdp->master_dir && block == sdp->master_dir->i_addr)
+ if (sdp->master_dir && block == sdp->master_dir->i_num.in_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_addr)
+ block == sdp->md.journal[j]->i_num.in_addr)
return sdp->md.journal[j];
return NULL;
}
@@ -90,7 +90,7 @@ 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_addr;
+ uint64_t block = ip->i_num.in_addr;
struct gfs2_sbd *sdp = ip->i_sbd;
if (ip->i_bh->b_modified) {
@@ -318,8 +318,8 @@ int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct gfs2_inode *ip, u
struct lgfs2_rbm rbm = { .rgd = rg, .offset = 0, .bii = 0 };
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)
+ if (ip->i_num.in_addr != 0) {
+ if (lgfs2_rbm_from_block(&rbm, ip->i_num.in_addr) != 0)
return 1;
} else if (lgfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &blocks) != 0) {
return 1;
@@ -334,16 +334,16 @@ int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct gfs2_inode *ip, u
ip->i_sbd = sdp;
ip->i_magic = GFS2_MAGIC;
- ip->i_type = GFS2_METATYPE_DI;
+ ip->i_mh_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_num.in_addr = lgfs2_rbm_to_block(&rbm);
+ ip->i_num.in_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_data = ip->i_num.in_addr + ip->i_blocks - 1;
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;
@@ -485,7 +485,7 @@ void block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
if (inode_is_stuffed(ip)) {
if (!lblock) {
- *dblock = ip->i_addr;
+ *dblock = ip->i_num.in_addr;
if (extlen)
*extlen = 1;
}
@@ -524,7 +524,7 @@ void block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
memcpy(bh->b_data, &mh, sizeof(mh));
bmodified(bh);
} else {
- if (*dblock == ip->i_addr)
+ if (*dblock == ip->i_num.in_addr)
bh = ip->i_bh;
else
bh = bread(sdp, *dblock);
@@ -626,7 +626,7 @@ int gfs2_readi(struct gfs2_inode *ip, void *buf,
}
if (dblock) {
- if (dblock == ip->i_addr)
+ if (dblock == ip->i_num.in_addr)
bh = ip->i_bh;
else
bh = bread(sdp, dblock);
@@ -718,7 +718,7 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf,
bmodified(bh);
}
} else {
- if (dblock == ip->i_addr)
+ if (dblock == ip->i_num.in_addr)
bh = ip->i_bh;
else
bh = bread(sdp, dblock);
@@ -1002,7 +1002,7 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
oleaf->lf_depth = cpu_to_be16(oleaf->lf_depth);
nleaf->lf_depth = oleaf->lf_depth;
- nleaf->lf_inode = cpu_to_be64(dip->i_addr);
+ nleaf->lf_inode = cpu_to_be64(dip->i_num.in_addr);
dip->i_blocks++;
bmodified(dip->i_bh);
@@ -1202,7 +1202,7 @@ 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_addr);
+ nleaf->lf_inode = cpu_to_be64(dip->i_num.in_addr);
err = dirent_alloc(dip, nbh, len, &dent);
if (err)
return err;
@@ -1255,7 +1255,7 @@ 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_entries);
- leaf->lf_inode = cpu_to_be64(dip->i_addr);
+ leaf->lf_inode = cpu_to_be64(dip->i_num.in_addr);
buffer_copy_tail(sdp, bh, sizeof(struct gfs2_leaf),
dip->i_bh, sizeof(struct gfs2_dinode));
@@ -1436,14 +1436,14 @@ int lgfs2_write_filemeta(struct gfs2_inode *ip)
struct metapath mp;
struct gfs2_sbd *sdp = ip->i_sbd;
uint64_t dblocks = (ip->i_size + sdp->sd_bsize - 1) / sdp->sd_bsize;
- uint64_t ptr0 = ip->i_addr + 1;
+ uint64_t ptr0 = ip->i_num.in_addr + 1;
unsigned ptrs = 1;
struct gfs2_meta_header mh = {
.mh_magic = cpu_to_be32(GFS2_MAGIC),
.mh_type = cpu_to_be32(GFS2_METATYPE_IN),
.mh_format = cpu_to_be32(GFS2_FORMAT_IN)
};
- struct gfs2_buffer_head *bh = bget(sdp, ip->i_addr);
+ struct gfs2_buffer_head *bh = bget(sdp, ip->i_num.in_addr);
if (bh == NULL)
return 1;
@@ -1495,10 +1495,8 @@ static struct gfs2_inode *__createi(struct gfs2_inode *dip,
gfs2_lookupi(dip, filename, strlen(filename), &ip);
if (!ip) {
- struct lgfs2_inum parent = {
- .in_formal_ino = dip->i_formal_ino,
- .in_addr = dip->i_addr,
- };
+ struct lgfs2_inum parent = dip->i_num;
+
err = lgfs2_dinode_alloc(sdp, 1, &bn);
if (err != 0)
return NULL;
diff --git a/gfs2/libgfs2/gfs1.c b/gfs2/libgfs2/gfs1.c
index 10a196df..feb8d22a 100644
--- a/gfs2/libgfs2/gfs1.c
+++ b/gfs2/libgfs2/gfs1.c
@@ -33,7 +33,7 @@ gfs1_metapointer(char *buf, unsigned int height, struct metapath *mp)
int is_gfs_dir(struct gfs2_inode *ip)
{
- if (ip->i_pad1 == GFS_FILE_DIR)
+ if (ip->i_di_type == GFS_FILE_DIR)
return 1;
return 0;
}
@@ -86,7 +86,7 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
if (!ip->i_height) { /* stuffed */
if (!lblock) {
- *dblock = ip->i_addr;
+ *dblock = ip->i_num.in_addr;
if (extlen)
*extlen = 1;
}
@@ -125,7 +125,7 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
memcpy(bh->b_data, &mh, sizeof(mh));
bmodified(bh);
} else {
- if (*dblock == ip->i_addr)
+ if (*dblock == ip->i_num.in_addr)
bh = ip->i_bh;
else
bh = bread(sdp, *dblock);
@@ -208,12 +208,12 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
return -1;
}
- if (dblock == ip->i_addr)
+ if (dblock == ip->i_num.in_addr)
bh = ip->i_bh;
else
bh = bread(sdp, dblock);
- if (journaled && dblock != ip->i_addr ) {
+ if (journaled && dblock != ip->i_num.in_addr ) {
struct gfs2_meta_header mh = {
.mh_magic = cpu_to_be32(GFS2_MAGIC),
.mh_type = cpu_to_be32(GFS2_METATYPE_JD),
@@ -256,10 +256,10 @@ static struct gfs2_inode *__gfs_inode_get(struct gfs2_sbd *sdp, char *buf)
}
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_mh_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_num.in_formal_ino = be64_to_cpu(di->di_num.no_formal_ino);
+ ip->i_num.in_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);
@@ -275,7 +275,7 @@ static struct gfs2_inode *__gfs_inode_get(struct gfs2_sbd *sdp, char *buf)
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_di_type = 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);
diff --git a/gfs2/libgfs2/gfs2l.c b/gfs2/libgfs2/gfs2l.c
index 2872d70e..15dcd25d 100644
--- a/gfs2/libgfs2/gfs2l.c
+++ b/gfs2/libgfs2/gfs2l.c
@@ -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_meta_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.in_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 f0870457..740d1a7b 100644
--- a/gfs2/libgfs2/lang.c
+++ b/gfs2/libgfs2/lang.c
@@ -158,11 +158,11 @@ 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_root_dir.no_addr);
+ ip = lgfs2_inode_read(sbd, sbd->sd_root_dir.in_addr);
while (ip != NULL) {
if (segment == NULL) { // No more segments
- bn = ip->i_addr;
+ bn = ip->i_num.in_addr;
inode_put(&ip);
return bn;
}
@@ -215,13 +215,13 @@ 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_meta_dir.no_addr;
+ bn = sbd->sd_meta_dir.in_addr;
break;
case ID_ROOT:
- bn = sbd->sd_root_dir.no_addr;
+ bn = sbd->sd_root_dir.in_addr;
break;
case ID_RINDEX:
- bn = sbd->md.riinode->i_addr;
+ bn = sbd->md.riinode->i_num.in_addr;
break;
default:
return 0;
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index 026edb1b..e3afa464 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -247,6 +247,11 @@ struct gfs2_buffer_head {
int b_modified;
};
+struct lgfs2_inum {
+ uint64_t in_formal_ino;
+ uint64_t in_addr;
+};
+
struct gfs2_inode {
struct gfs2_buffer_head *i_bh;
struct gfs2_sbd *i_sbd;
@@ -255,10 +260,9 @@ struct gfs2_inode {
/* Native-endian versions of the dinode fields */
uint32_t i_magic;
- uint32_t i_type;
+ uint32_t i_mh_type;
uint32_t i_format;
- uint64_t i_formal_ino;
- uint64_t i_addr;
+ struct lgfs2_inum i_num;
uint32_t i_mode;
uint32_t i_uid;
uint32_t i_gid;
@@ -270,23 +274,32 @@ struct gfs2_inode {
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;
+ union {
+ struct { /* gfs2 */
+ uint64_t i_goal_meta;
+ uint64_t i_goal_data;
+ uint64_t i_generation;
+ uint32_t i_atime_nsec;
+ uint32_t i_mtime_nsec;
+ uint32_t i_ctime_nsec;
+ };
+ struct { /* gfs */
+ uint64_t i_rgrp;
+ uint32_t i_goal_rgrp;
+ uint32_t i_goal_dblk;
+ uint32_t i_goal_mblk;
+ uint16_t i_di_type;
+ uint32_t i_incarn;
+ struct lgfs2_inum i_next_unused;
+ };
+ };
};
struct master_dir
@@ -312,15 +325,12 @@ struct gfs2_sbd {
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 */
+ struct lgfs2_inum sd_meta_dir;
+ struct lgfs2_inum sd_root_dir;
+ struct lgfs2_inum sd_rindex_di; /* gfs1 */
+ struct lgfs2_inum sd_jindex_di; /* gfs1 */
+ struct lgfs2_inum sd_quota_di; /* gfs1 */
+ struct lgfs2_inum sd_license_di; /* gfs1 */
uint32_t sd_bsize_shift;
uint32_t sd_seg_size;
char sd_lockproto[GFS2_LOCKNAME_LEN];
@@ -375,11 +385,6 @@ struct gfs2_sbd {
int gfs1;
};
-struct lgfs2_inum {
- uint64_t in_formal_ino;
- uint64_t in_addr;
-};
-
struct lgfs2_log_header {
uint64_t lh_sequence;
uint32_t lh_flags;
@@ -808,7 +813,7 @@ extern void print_it(const char *label, const char *fmt, const char *fmt2, ...)
/* Translation functions */
extern void lgfs2_inum_in(struct lgfs2_inum *i, void *inp);
-extern void lgfs2_inum_out(struct lgfs2_inum *i, void *inp);
+extern void lgfs2_inum_out(const struct lgfs2_inum *i, void *inp);
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);
diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c
index 5d2f4a6b..4daf1be1 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -30,7 +30,7 @@ void lgfs2_inum_in(struct lgfs2_inum *i, void *inp)
i->in_addr = be64_to_cpu(in->no_addr);
}
-void lgfs2_inum_out(struct lgfs2_inum *i, void *inp)
+void lgfs2_inum_out(const struct lgfs2_inum *i, void *inp)
{
struct gfs2_inum *in = inp;
@@ -66,18 +66,13 @@ void lgfs2_sb_in(struct gfs2_sbd *sdp, void *buf)
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(sb1->sb_seg_size);
- 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);
+ lgfs2_inum_in(&sdp->sd_meta_dir, &sb->sb_master_dir);
+ lgfs2_inum_in(&sdp->sd_root_dir, &sb->sb_root_dir);
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(sb1->sb_rindex_di.no_formal_ino);
- sdp->sd_rindex_di.no_addr = be64_to_cpu(sb1->sb_rindex_di.no_addr);
- sdp->sd_quota_di.no_formal_ino = be64_to_cpu(sb1->sb_quota_di.no_formal_ino);
- sdp->sd_quota_di.no_addr = be64_to_cpu(sb1->sb_quota_di.no_addr);
- sdp->sd_license_di.no_formal_ino = be64_to_cpu(sb1->sb_license_di.no_formal_ino);
- sdp->sd_license_di.no_addr = be64_to_cpu(sb1->sb_license_di.no_addr);
+ lgfs2_inum_in(&sdp->sd_rindex_di, &sb1->sb_rindex_di);
+ lgfs2_inum_in(&sdp->sd_quota_di, &sb1->sb_quota_di);
+ lgfs2_inum_in(&sdp->sd_license_di, &sb1->sb_license_di);
memcpy(sdp->sd_uuid, sb->sb_uuid, sizeof(sdp->sd_uuid));
}
@@ -95,18 +90,13 @@ void lgfs2_sb_out(const struct gfs2_sbd *sdp, void *buf)
sb->sb_bsize = cpu_to_be32(sdp->sd_bsize);
sb->sb_bsize_shift = cpu_to_be32(sdp->sd_bsize_shift);
sb1->sb_seg_size = 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);
+ lgfs2_inum_out(&sdp->sd_meta_dir, &sb->sb_master_dir);
+ lgfs2_inum_out(&sdp->sd_root_dir, &sb->sb_root_dir);
memcpy(sb->sb_lockproto, sdp->sd_lockproto, GFS2_LOCKNAME_LEN);
memcpy(sb->sb_locktable, sdp->sd_locktable, GFS2_LOCKNAME_LEN);
- sb1->sb_rindex_di.no_formal_ino = cpu_to_be64(sdp->sd_rindex_di.no_formal_ino);
- sb1->sb_rindex_di.no_addr = cpu_to_be64(sdp->sd_rindex_di.no_addr);
- sb1->sb_quota_di.no_formal_ino = cpu_to_be64(sdp->sd_quota_di.no_formal_ino);
- sb1->sb_quota_di.no_addr = cpu_to_be64(sdp->sd_quota_di.no_addr);
- sb1->sb_license_di.no_formal_ino = cpu_to_be64(sdp->sd_license_di.no_formal_ino);
- sb1->sb_license_di.no_addr = cpu_to_be64(sdp->sd_license_di.no_addr);
+ lgfs2_inum_out(&sdp->sd_rindex_di, &sb1->sb_rindex_di);
+ lgfs2_inum_out(&sdp->sd_quota_di, &sb1->sb_quota_di);
+ lgfs2_inum_out(&sdp->sd_license_di, &sb1->sb_license_di);
memcpy(sb->sb_uuid, sdp->sd_uuid, 16);
}
@@ -223,10 +213,9 @@ void lgfs2_dinode_in(struct gfs2_inode *ip, char *buf)
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_mh_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);
+ lgfs2_inum_in(&ip->i_num, &di->di_num);
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);
@@ -243,14 +232,9 @@ void lgfs2_dinode_in(struct gfs2_inode *ip, char *buf)
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);
@@ -262,10 +246,9 @@ void lgfs2_dinode_out(struct gfs2_inode *ip, char *buf)
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_type = cpu_to_be32(ip->i_mh_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);
+ lgfs2_inum_out(&ip->i_num, &di->di_num);
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);
@@ -277,23 +260,14 @@ void lgfs2_dinode_out(struct gfs2_inode *ip, char *buf)
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);
diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c
index 9dcf237f..ae5de7e1 100644
--- a/gfs2/libgfs2/structures.c
+++ b/gfs2/libgfs2/structures.c
@@ -110,7 +110,7 @@ int lgfs2_write_journal_data(struct gfs2_inode *ip)
{
struct gfs2_sbd *sdp = ip->i_sbd;
unsigned blocks = (ip->i_size + sdp->sd_bsize - 1) / sdp->sd_bsize;
- uint64_t jext0 = ip->i_addr + ip->i_blocks - blocks;
+ uint64_t jext0 = ip->i_num.in_addr + ip->i_blocks - blocks;
uint64_t seq = ((blocks) * (random() / (RAND_MAX + 1.0)));
struct gfs2_log_header *lh;
uint64_t jblk = jext0;
@@ -125,7 +125,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_addr);
+ lh->lh_jinode = cpu_to_be64(ip->i_num.in_addr);
crc32c_optimization_init();
do {
@@ -174,7 +174,7 @@ static struct gfs2_buffer_head *get_file_buf(struct gfs2_inode *ip, uint64_t lbn
bmodified(ip->i_bh);
ip->i_size = (lbn + 1) << sdp->sd_bsize_shift;
}
- if (dbn == ip->i_addr)
+ if (dbn == ip->i_num.in_addr)
return ip->i_bh;
else
return bread(sdp, dbn);
@@ -212,7 +212,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_addr);
+ lh->lh_jinode = cpu_to_be64(jnl->i_num.in_addr);
lh->lh_sequence = cpu_to_be64(seq);
lh->lh_blkno = cpu_to_be32(x);
diff --git a/gfs2/mkfs/main_grow.c b/gfs2/mkfs/main_grow.c
index 8204d263..0f8e7d9e 100644
--- a/gfs2/mkfs/main_grow.c
+++ b/gfs2/mkfs/main_grow.c
@@ -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_meta_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.in_addr);
if (sdp->master_dir == NULL) {
perror(_("Could not read master directory"));
exit(EXIT_FAILURE);
diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c
index 551261b9..bca7b9d1 100644
--- a/gfs2/mkfs/main_mkfs.c
+++ b/gfs2/mkfs/main_mkfs.c
@@ -874,7 +874,7 @@ static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, struct mkfs_o
}
/* Allocate at the beginning of the rgrp, bypassing extent search */
lgfs2_rindex_out(rg, &ri);
- in.i_addr = be64_to_cpu(ri.ri_data0);
+ in.i_num.in_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 */
@@ -901,8 +901,7 @@ 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_addr = in.i_addr;
- mkfs_journals[j].in_formal_ino = in.i_formal_ino;
+ mkfs_journals[j] = in.i_num;
}
gfs2_progress_close(&progress, _("Done\n"));
@@ -1207,8 +1206,7 @@ int main(int argc, char *argv[])
fprintf(stderr, _("Error building '%s': %s\n"), "master", strerror(errno));
exit(EXIT_FAILURE);
}
- sbd.sd_meta_dir.no_addr = sbd.master_dir->i_addr;
- sbd.sd_meta_dir.no_formal_ino = sbd.master_dir->i_formal_ino;
+ sbd.sd_meta_dir = sbd.master_dir->i_num;
error = lgfs2_build_jindex(sbd.master_dir, mkfs_journals, opts.journals);
if (error) {
@@ -1251,8 +1249,7 @@ int main(int argc, char *argv[])
printf("%s", _("Done\n"));
build_root(&sbd);
- sbd.sd_root_dir.no_addr = sbd.md.rooti->i_addr;
- sbd.sd_root_dir.no_formal_ino = sbd.md.rooti->i_formal_ino;
+ sbd.sd_root_dir = sbd.md.rooti->i_num;
strncpy(sbd.sd_lockproto, opts.lockproto, GFS2_LOCKNAME_LEN - 1);
strncpy(sbd.sd_locktable, opts.locktable, GFS2_LOCKNAME_LEN - 1);
diff --git a/tests/nukerg.c b/tests/nukerg.c
index b5ddeb0b..399f7373 100644
--- a/tests/nukerg.c
+++ b/tests/nukerg.c
@@ -288,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_meta_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.in_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