5 a.m.
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.