This is an automated email from the git hooks/post-receive script.
andyp pushed a commit to branch master in repository gfs2-utils.
commit 301af4179d329b0002c0413dc640a3c0038ece74 Author: Andrew Price anprice@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@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;
cluster-commits@lists.fedorahosted.org
-
pagure＠pagure.io