This is an automated email from the git hooks/post-receive script.
andyp pushed a commit to branch andyp-sparse in repository gfs2-utils.
commit fd2951b3d419e5fe61e4245b076341d1850e21b0 Author: Andrew Price anprice@redhat.com AuthorDate: Fri May 14 15:42:30 2021 +0100
libgfs2: Remove i_di from struct gfs2_inode
To stop storing native-endian data in a struct gfs2_dinode, its fields are duplicated into struct gfs2_inode using uint*_t types and the in/out/print functions updated to work directly with the struct gfs2_inode. This requires a few intermediate gfs2_inums to be used in places that previously used i_di.di_num as a whole. They will be resolved once a native-endian replacement for gfs2_inums is added.
Unfortunately the large size of this patch is necessary as the switch is an all-or-nothing deal, but most of it is fairly mechanical.
Signed-off-by: Andrew Price anprice@redhat.com --- gfs2/convert/gfs2_convert.c | 154 +++++++------- gfs2/edit/extended.c | 10 +- gfs2/edit/hexedit.c | 12 +- gfs2/edit/journal.c | 16 +- gfs2/fsck/afterpass1_common.c | 29 ++- gfs2/fsck/fs_recovery.c | 29 ++- gfs2/fsck/initialize.c | 185 ++++++++--------- gfs2/fsck/link.c | 35 ++-- gfs2/fsck/lost_n_found.c | 143 +++++++------ gfs2/fsck/main.c | 7 +- gfs2/fsck/metawalk.c | 286 +++++++++++--------------- gfs2/fsck/pass1.c | 453 +++++++++++++++++------------------------- gfs2/fsck/pass1b.c | 62 +++--- gfs2/fsck/pass2.c | 390 ++++++++++++++++-------------------- gfs2/fsck/pass3.c | 23 ++- gfs2/fsck/pass4.c | 31 ++- gfs2/fsck/rgrepair.c | 25 +-- gfs2/fsck/util.c | 47 ++--- gfs2/fsck/util.h | 12 +- gfs2/glocktop/glocktop.c | 19 +- gfs2/libgfs2/fs_ops.c | 215 ++++++++++---------- gfs2/libgfs2/gfs1.c | 122 +++++------- gfs2/libgfs2/lang.c | 4 +- gfs2/libgfs2/libgfs2.h | 42 +++- gfs2/libgfs2/ondisk.c | 140 +++++++------ gfs2/libgfs2/recovery.c | 8 +- gfs2/libgfs2/structures.c | 38 ++-- gfs2/libgfs2/super.c | 2 +- gfs2/mkfs/main_mkfs.c | 11 +- tests/nukerg.c | 2 +- 30 files changed, 1164 insertions(+), 1388 deletions(-)
diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c index cca60598..d1cccd59 100644 --- a/gfs2/convert/gfs2_convert.c +++ b/gfs2/convert/gfs2_convert.c @@ -209,10 +209,10 @@ static unsigned int calc_gfs2_tree_height(struct gfs2_inode *ip, uint64_t size) uint64_t *arr; unsigned int max, height;
- if (ip->i_di.di_size > size) - size = ip->i_di.di_size; + if (ip->i_size > size) + size = ip->i_size;
- if (S_ISDIR(ip->i_di.di_mode)) { + if (S_ISDIR(ip->i_mode)) { arr = gfs2_jheightsize; max = gfs2_max_jheight; } else { @@ -290,7 +290,7 @@ static void fix_metatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip, mh.mh_magic = GFS2_MAGIC; mh.mh_type = GFS2_METATYPE_IN; mh.mh_format = GFS2_FORMAT_IN; - if (!ip->i_di.di_height) + if (!ip->i_height) unstuff_dinode(ip);
ptramt = blk->mp.mp_list[blk->height] * sizeof(uint64_t); @@ -448,7 +448,7 @@ static uint64_t fix_jdatatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip, mh.mh_type = GFS2_METATYPE_IN; mh.mh_format = GFS2_FORMAT_IN;
- if (!ip->i_di.di_height) + if (!ip->i_height) unstuff_dinode(ip);
ptramt = blk->mp.mp_list[blk->height]; @@ -540,7 +540,7 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip, str osi_list_foreach(tmp, &blocks->list) { blk = osi_list_entry(tmp, struct blocklist, list);
- if (blk->height >= ip->i_di.di_height - 1) + if (blk->height >= ip->i_height - 1) continue; for (ptr1 = (uint64_t *)blk->ptrbuf, ptrnum = 0; ptrnum < sbp->sd_inptrs; ptr1++, ptrnum++) { @@ -579,7 +579,7 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip, str brelse(bh); /* Free the block so we can reuse it. This allows us to convert a "full" file system. */ - ip->i_di.di_blocks--; + ip->i_blocks--; gfs2_free_block(sbp, block); } } @@ -622,7 +622,7 @@ static int fix_ind_reg_or_dir(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint3 blk->height -= di_height - gfs2_hgt; if (len) { fix_metatree(sbp, ip, blk, ptr1, len); - ip->i_di.di_goal_meta = be64_to_cpu(*ptr2); + ip->i_goal_meta = be64_to_cpu(*ptr2); }
return 0; @@ -671,7 +671,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint32_t d newblk->mp.mp_list[h] = blk->mp.mp_list[h]; newblk->mp.mp_list[h] = ptrnum; bh = bread(sbp, block); - /* This is a data block. i.e newblk->height == ip->i_di.di_height */ + /* This is a data block. i.e newblk->height == ip->i_height */ /* read in the jdata block */ memcpy(newblk->ptrbuf, bh->b_data + sizeof(struct gfs2_meta_header), bufsize); @@ -680,7 +680,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint32_t d brelse(bh); /* Free the block so we can reuse it. This allows us to convert a "full" file system */ - ip->i_di.di_blocks--; + ip->i_blocks--; gfs2_free_block(sbp, block);
len = bufsize; @@ -689,7 +689,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip, uint32_t d memcpy(&newblk->mp, &gfs2mp, sizeof(struct metapath)); newblk->height -= di_height - gfs2_hgt; if (len) - ip->i_di.di_goal_meta = fix_jdatatree(sbp, ip, newblk, + ip->i_goal_meta = fix_jdatatree(sbp, ip, newblk, newblk->ptrbuf, len); free(newblk->ptrbuf); free(newblk); @@ -705,17 +705,17 @@ static int adjust_indirect_blocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip) struct blocklist blocks, *blk; int error = 0;
- int isdir = S_ISDIR(ip->i_di.di_mode); /* is always jdata */ - int isjdata = ((GFS2_DIF_JDATA & ip->i_di.di_flags) && !isdir); + int isdir = S_ISDIR(ip->i_mode); /* is always jdata */ + int isjdata = ((GFS2_DIF_JDATA & ip->i_flags) && !isdir); int isreg = (!isjdata && !isdir); - int issys = (GFS2_DIF_SYSTEM & ip->i_di.di_flags); + int issys = (GFS2_DIF_SYSTEM & ip->i_flags);
/* regular files and dirs are same upto height=2 jdata files (not dirs) are same only when height=0 */ - if (((isreg||isdir) && ip->i_di.di_height <= 1) || - (isjdata && ip->i_di.di_height == 0)) { + if (((isreg||isdir) && ip->i_height <= 1) || + (isjdata && ip->i_height == 0)) { if (!issys) - ip->i_di.di_goal_meta = ip->i_di.di_num.no_addr; + ip->i_goal_meta = ip->i_addr; return 0; /* nothing to do */ }
@@ -727,13 +727,13 @@ static int adjust_indirect_blocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip)
/* The gfs2 height may be different. We need to rebuild the metadata tree to the gfs2 height. */ - gfs2_hgt = calc_gfs2_tree_height(ip, ip->i_di.di_size); + gfs2_hgt = calc_gfs2_tree_height(ip, ip->i_size); /* Save off the size because we're going to empty the contents and add the data blocks back in later. */ - dinode_size = ip->i_di.di_size; - ip->i_di.di_size = 0ULL; - di_height = ip->i_di.di_height; - ip->i_di.di_height = 0; + dinode_size = ip->i_size; + ip->i_size = 0ULL; + di_height = ip->i_height; + ip->i_height = 0;
/* Now run through the block list a second time. If the block is a data block, rewrite the data to the gfs2 offset. */ @@ -762,11 +762,11 @@ static int adjust_indirect_blocks(struct gfs2_sbd *sbp, struct gfs2_inode *ip) free(blk); }
- ip->i_di.di_size = dinode_size; + ip->i_size = dinode_size;
/* Set the new dinode height, which may or may not have changed. */ /* The caller will take it from the ip and write it to the buffer */ - ip->i_di.di_height = gfs2_hgt; + ip->i_height = gfs2_hgt; return error;
out: @@ -794,7 +794,7 @@ static int fix_cdpn_symlink(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, s { char *linkptr = NULL;
- if (ip->i_di.di_height != 0) + if (ip->i_height != 0) return 0;
linkptr = bh->b_data + sizeof(struct gfs_dinode); @@ -807,7 +807,7 @@ static int fix_cdpn_symlink(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, s return -1; } memset(fix, 0, sizeof(struct inode_dir_block)); - fix->di_addr = ip->i_di.di_num.no_addr; + fix->di_addr = ip->i_addr; osi_list_add_prev((osi_list_t *)&fix->list, (osi_list_t *)&cdpns_to_fix); } @@ -817,7 +817,7 @@ static int fix_cdpn_symlink(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, s
/* * fix_xattr - - * Extended attributes can be either direct (in the ip->i_di.di_eattr block) or + * Extended attributes can be either direct (in the ip->i_eattr block) or * then can be at a maximum of 1 indirect level. Multiple levels of indirection * are not supported. If the di_eattr block contains extended attribute data, * i.e block type = GFS_METATYPE_EA, we ignore it. @@ -831,8 +831,8 @@ static int fix_xattr(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh, struct g struct gfs2_buffer_head *eabh; char *buf;
- /* Read in the i_di.di_eattr block */ - eabh = bread(sbp, ip->i_di.di_eattr); + /* Read in the i_eattr block */ + eabh = bread(sbp, ip->i_eattr); if (!gfs2_check_meta(eabh->b_data, GFS_METATYPE_IN)) {/* if it is an indirect block */ len = sbp->bsize - sizeof(struct gfs_indirect); buf = malloc(len); @@ -871,16 +871,15 @@ static int adjust_inode(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh) return -1; }
- inode_was_gfs1 = (inode->i_di.di_num.no_formal_ino == - inode->i_di.di_num.no_addr); + inode_was_gfs1 = (inode->i_formal_ino == inode->i_addr); /* Fix the inode number: */ - inode->i_di.di_num.no_formal_ino = sbp->md.next_inum; + inode->i_formal_ino = sbp->md.next_inum;
/* Fix the inode type: gfs1 uses di_type, gfs2 uses di_mode. */ - inode->i_di.di_mode &= ~S_IFMT; - switch (inode->i_di.__pad1) { /* formerly di_type */ + inode->i_mode &= ~S_IFMT; + switch (inode->i_pad1) { /* formerly di_type */ case GFS_FILE_DIR: /* directory */ - inode->i_di.di_mode |= S_IFDIR; + inode->i_mode |= S_IFDIR; /* Add this directory to the list of dirs to fix later. */ fixdir = malloc(sizeof(struct inode_block)); if (!fixdir) { @@ -889,27 +888,27 @@ static int adjust_inode(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh) goto err_freei; } memset(fixdir, 0, sizeof(struct inode_block)); - fixdir->di_addr = inode->i_di.di_num.no_addr; + fixdir->di_addr = inode->i_addr; osi_list_add_prev((osi_list_t *)&fixdir->list, (osi_list_t *)&dirs_to_fix); break; case GFS_FILE_REG: /* regular file */ - inode->i_di.di_mode |= S_IFREG; + inode->i_mode |= S_IFREG; break; case GFS_FILE_LNK: /* symlink */ - inode->i_di.di_mode |= S_IFLNK; + inode->i_mode |= S_IFLNK; break; case GFS_FILE_BLK: /* block device */ - inode->i_di.di_mode |= S_IFBLK; + inode->i_mode |= S_IFBLK; break; case GFS_FILE_CHR: /* character device */ - inode->i_di.di_mode |= S_IFCHR; + inode->i_mode |= S_IFCHR; break; case GFS_FILE_FIFO: /* fifo / pipe */ - inode->i_di.di_mode |= S_IFIFO; + inode->i_mode |= S_IFIFO; break; case GFS_FILE_SOCK: /* socket */ - inode->i_di.di_mode |= S_IFSOCK; + inode->i_mode |= S_IFSOCK; break; }
@@ -930,25 +929,26 @@ static int adjust_inode(struct gfs2_sbd *sbp, struct gfs2_buffer_head *bh) /* don't want to shift the data around. */ /* ----------------------------------------------------------- */ if (inode_was_gfs1) { - struct gfs_dinode *gfs1_dinode_struct; + struct { + uint32_t dblk; + uint32_t mblk; + } *gfs1_goals = (void *)&inode->i_generation; int ret = 0;
- gfs1_dinode_struct = (struct gfs_dinode *)&inode->i_di; - inode->i_di.di_goal_meta = inode->i_di.di_goal_data; - inode->i_di.di_goal_data = 0; /* make sure the upper 32b are 0 */ - inode->i_di.di_goal_data = gfs1_dinode_struct->di_goal_dblk; - inode->i_di.di_generation = 0; + inode->i_goal_meta = inode->i_goal_data; + inode->i_goal_data = (uint64_t)gfs1_goals->dblk; + inode->i_generation = 0;
if (adjust_indirect_blocks(sbp, inode)) goto err_freei; /* Check for cdpns */ - if (S_ISLNK(inode->i_di.di_mode)) { + if (S_ISLNK(inode->i_mode)) { ret = fix_cdpn_symlink(sbp, bh, inode); if (ret) goto err_freei; } /* Check for extended attributes */ - if (inode->i_di.di_eattr) { + if (inode->i_eattr) { ret = fix_xattr(sbp, bh, inode); if (ret) goto err_freei; @@ -1124,10 +1124,10 @@ static int fetch_inum(struct gfs2_sbd *sbp, uint64_t iblock, fix_inode = lgfs2_inode_read(sbp, iblock); if (fix_inode == NULL) return 1; - inum->no_formal_ino = fix_inode->i_di.di_num.no_formal_ino; - inum->no_addr = fix_inode->i_di.di_num.no_addr; + inum->no_formal_ino = fix_inode->i_formal_ino; + inum->no_addr = fix_inode->i_addr; if (eablk) - *eablk = fix_inode->i_di.di_eattr; + *eablk = fix_inode->i_eattr;
inode_put(&fix_inode); return 0; @@ -1239,7 +1239,7 @@ static int process_dirent_info(struct gfs2_inode *dip, struct gfs2_sbd *sbp, osi_list_foreach(tmp, &cdpns_to_fix.list) { fix = osi_list_entry(tmp, struct inode_dir_block, list); if (fix->di_addr == inum.no_addr) - fix->di_paddr = dip->i_di.di_num.no_addr; + fix->di_paddr = dip->i_addr; } }
@@ -1324,14 +1324,14 @@ static int process_directory(struct gfs2_sbd *sbp, uint64_t dirblock, uint64_t d if (dip == NULL) return -1; /* fix the directory: either exhash (leaves) or linear (stuffed) */ - if (dip->i_di.di_flags & GFS2_DIF_EXHASH) { + if (dip->i_flags & GFS2_DIF_EXHASH) { if (fix_one_directory_exhash(sbp, dip, dentmod)) { log_crit(_("Error fixing exhash directory.\n")); inode_put(&dip); return -1; } } else { - error = process_dirent_info(dip, sbp, dip->i_bh, dip->i_di.di_entries, dentmod); + error = process_dirent_info(dip, sbp, dip->i_bh, dip->i_entries, dentmod); if (error && error != -EISDIR) { log_crit(_("Error fixing linear directory.\n")); inode_put(&dip); @@ -1430,7 +1430,7 @@ static int fix_cdpn_symlinks(struct gfs2_sbd *sbp, osi_list_t *cdpn_to_fix) fix_inode = lgfs2_inode_get(sbp, bh); if (fix_inode == NULL) return -1; - fix_inode->i_di.di_eattr = eablk; /*fix extended attribute */ + fix_inode->i_eattr = eablk; /*fix extended attribute */ inode_put(&fix_inode); bmodified(bh); brelse(bh); @@ -1471,17 +1471,17 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp) int error=0; unsigned int tmp_mode = 0;
- if(ip->i_di.di_size % sizeof(struct gfs_jindex) != 0){ + if(ip->i_size % sizeof(struct gfs_jindex) != 0){ log_crit(_("The size reported in the journal index" " inode is not a\n" "\tmultiple of the size of a journal index.\n")); return -1; } - if(!(sd_jindex = (struct gfs_jindex *)malloc(ip->i_di.di_size))) { + if(!(sd_jindex = (struct gfs_jindex *)malloc(ip->i_size))) { log_crit(_("Unable to allocate journal index\n")); return -1; } - if(!memset(sd_jindex, 0, ip->i_di.di_size)) { + if(!memset(sd_jindex, 0, ip->i_size)) { log_crit(_("Unable to zero journal index\n")); return -1; } @@ -1490,9 +1490,9 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp) * so it skips the metaheader struct in the data blocks * in the inode. gfs2_jindex inode doesn't have metaheaders * in the data blocks */ - tmp_mode = ip->i_di.di_mode; - ip->i_di.di_mode &= ~S_IFMT; - ip->i_di.di_mode |= S_IFDIR; + tmp_mode = ip->i_mode; + ip->i_mode &= ~S_IFMT; + ip->i_mode |= S_IFDIR; for (j = 0; ; j++) { struct gfs_jindex *journ;
@@ -1509,8 +1509,8 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp) gfs1_jindex_in(journ, buf); sdp->jsize = (journ->ji_nsegment * 16 * sdp->bsize) >> 20; } - ip->i_di.di_mode = tmp_mode; - if(j * sizeof(struct gfs_jindex) != ip->i_di.di_size){ + ip->i_mode = tmp_mode; + if(j * sizeof(struct gfs_jindex) != ip->i_size){ log_crit(_("journal inode size invalid\n")); goto fail; } @@ -1710,8 +1710,8 @@ static int init(struct gfs2_sbd *sbp, struct gfs2_options *opts) /* apparently only for directories. So we need to fake out libgfs2 */ /* so that it adjusts for the metaheader by faking out the inode to */ /* look like a directory, temporarily. */ - sbp->md.riinode->i_di.di_mode &= ~S_IFMT; - sbp->md.riinode->i_di.di_mode |= S_IFDIR; + sbp->md.riinode->i_mode &= ~S_IFMT; + sbp->md.riinode->i_mode |= S_IFDIR; printf(_("Examining file system")); if (gfs1_ri_update(sbp, &rgcount, 0)){ log_crit(_("Unable to fill in resource group information.\n")); @@ -2158,15 +2158,15 @@ static void copy_quotas(struct gfs2_sbd *sdp) exit(1); }
- nq_ip->i_di.di_height = oq_ip->i_di.di_height; - nq_ip->i_di.di_size = oq_ip->i_di.di_size; - nq_ip->i_di.di_blocks = oq_ip->i_di.di_blocks; + nq_ip->i_height = oq_ip->i_height; + nq_ip->i_size = oq_ip->i_size; + nq_ip->i_blocks = oq_ip->i_blocks; memcpy(nq_ip->i_bh->b_data + sizeof(struct gfs2_dinode), oq_ip->i_bh->b_data + sizeof(struct gfs2_dinode), sdp->bsize - sizeof(struct gfs2_dinode));
- oq_ip->i_di.di_height = 0; - oq_ip->i_di.di_size = 0; + oq_ip->i_height = 0; + oq_ip->i_size = 0;
bmodified(nq_ip->i_bh); inode_put(&nq_ip); @@ -2321,7 +2321,8 @@ int main(int argc, char **argv) "GFS2 file system structures.\n"), sb2.jsize); /* Build the master subdirectory. */ build_master(&sb2); /* Does not do inode_put */ - sb2.sd_sb.sb_master_dir = sb2.master_dir->i_di.di_num; + sb2.sd_sb.sb_master_dir.no_addr = sb2.master_dir->i_addr; + sb2.sd_sb.sb_master_dir.no_formal_ino = sb2.master_dir->i_formal_ino; /* Build empty journal index file. */ error = conv_build_jindex(&sb2); if (error) { @@ -2370,11 +2371,8 @@ int main(int argc, char **argv) }
/* Copy out the master dinode */ - { - struct gfs2_inode *ip = sb2.master_dir; - if (ip->i_bh->b_modified) - gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data); - } + if (sb2.master_dir->i_bh->b_modified) + lgfs2_dinode_out(sb2.master_dir, sb2.master_dir->i_bh->b_data); /* Copy old quotas */ copy_quotas(&sb2);
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c index c977b6e1..f3b1bba0 100644 --- a/gfs2/edit/extended.c +++ b/gfs2/edit/extended.c @@ -439,7 +439,7 @@ static int print_gfs_jindex(struct gfs2_inode *dij)
start_line = line; print_gfs2("Journal index entries found: %"PRIu64".", - dij->i_di.di_size / sizeof(struct gfs_jindex)); + dij->i_size / sizeof(struct gfs_jindex)); eol(0); lines_per_row[dmode] = 4; for (print_entry_ndx=0; ; print_entry_ndx++) { @@ -483,7 +483,7 @@ static int print_gfs2_jindex(void) print_gfs2("%s: 0x%-5"PRIx64" %"PRIu64"MB ", indirect->ii[0].dirent[d].filename, indirect->ii[0].dirent[d].block, - ip->i_di.di_size / 1048576); + ip->i_size / 1048576); error = lgfs2_find_jhead(ip, &head); if (error) { print_gfs2("corrupt."); @@ -507,8 +507,8 @@ static int parse_rindex(struct gfs2_inode *dip, int print_rindex) char highlighted_addr[32];
start_line = line; - print_gfs2("RG index entries found: %"PRIu64".", dip->i_di.di_size / - sizeof(struct gfs2_rindex)); + print_gfs2("RG index entries found: %"PRIu64".", + dip->i_size / sizeof(struct gfs2_rindex)); eol(0); lines_per_row[dmode] = 6; memset(highlighted_addr, 0, sizeof(highlighted_addr)); @@ -612,7 +612,7 @@ static int print_quota(struct gfs2_inode *diq)
print_gfs2("quota file contents:"); eol(0); - print_gfs2("quota entries found: %"PRIu64".", diq->i_di.di_size / sizeof(q)); + print_gfs2("quota entries found: %"PRIu64".", diq->i_size / sizeof(q)); eol(0); for (i=0; ; i++) { error = gfs2_readi(diq, &q, i * sizeof(q), sizeof(q)); diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c index 2e647211..4fbe071d 100644 --- a/gfs2/edit/hexedit.c +++ b/gfs2/edit/hexedit.c @@ -696,9 +696,8 @@ uint64_t masterblock(const char *fn) /* ------------------------------------------------------------------------ */ static void rgcount(void) { - printf("%lld RGs in this file system.\n", - (unsigned long long)sbd.md.riinode->i_di.di_size / - sizeof(struct gfs2_rindex)); + printf("%"PRId64" RGs in this file system.\n", + sbd.md.riinode->i_size / sizeof(struct gfs2_rindex)); inode_put(&sbd.md.riinode); gfs2_rgrp_free(&sbd, &sbd.rgtree); exit(EXIT_SUCCESS); @@ -762,12 +761,11 @@ static uint64_t get_rg_addr(int rgnum) riinode = lgfs2_inode_read(&sbd, gblock); if (riinode == NULL) return 0; - if (rgnum < riinode->i_di.di_size / sizeof(struct gfs2_rindex)) + if (rgnum < riinode->i_size / sizeof(struct gfs2_rindex)) rgblk = find_rgrp_block(riinode, rgnum); else - fprintf(stderr, "Error: File system only has %lld RGs.\n", - (unsigned long long)riinode->i_di.di_size / - sizeof(struct gfs2_rindex)); + fprintf(stderr, "Error: File system only has %"PRId64" RGs.\n", + riinode->i_size / sizeof(struct gfs2_rindex)); inode_put(&riinode); return rgblk; } diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c index 607f65e5..13b8c121 100644 --- a/gfs2/edit/journal.c +++ b/gfs2/edit/journal.c @@ -73,14 +73,14 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size) } inode_put(&jiinode); } else { - struct gfs2_dinode jdi; + struct gfs2_dinode *jdi;
if (journal_num > indirect->ii[0].dirents - 2) return 0; jblock = indirect->ii[0].dirent[journal_num + 2].block; j_bh = bread(&sbd, jblock); - gfs2_dinode_in(&jdi, j_bh->b_data); - *j_size = jdi.di_size; + jdi = (struct gfs2_dinode *)j_bh->b_data; + *j_size = be64_to_cpu(jdi->di_size); brelse(j_bh); } brelse(jindex_bh); @@ -122,12 +122,12 @@ static int fsck_readi(struct gfs2_inode *ip, void *rbuf, uint64_t roffset, if (ip == NULL) return 0; sdp = ip->i_sbd; - isdir = !!(S_ISDIR(ip->i_di.di_mode)); + isdir = !!(S_ISDIR(ip->i_mode)); *abs_block = 0; - if (roffset >= ip->i_di.di_size) + if (roffset >= ip->i_size) return 0; - if ((roffset + size) > ip->i_di.di_size) - size = ip->i_di.di_size - roffset; + if ((roffset + size) > ip->i_size) + size = ip->i_size - roffset; if (!size) return 0; if (isdir) { @@ -138,7 +138,7 @@ static int fsck_readi(struct gfs2_inode *ip, void *rbuf, uint64_t roffset, o = roffset & (sdp->bsize - 1); }
- if (!ip->i_di.di_height) /* inode_is_stuffed */ + if (!ip->i_height) /* inode_is_stuffed */ o += sizeof(struct gfs2_dinode); else if (isdir) o += sizeof(struct gfs2_meta_header); diff --git a/gfs2/fsck/afterpass1_common.c b/gfs2/fsck/afterpass1_common.c index 82b9a54c..35029202 100644 --- a/gfs2/fsck/afterpass1_common.c +++ b/gfs2/fsck/afterpass1_common.c @@ -86,12 +86,9 @@ static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t block,
q = bitmap_type(ip->i_sbd, block); if (q == GFS2_BLKST_FREE) { - log_info( _("%s block %lld (0x%llx), part of inode " - "%lld (0x%llx), was already free.\n"), - btype, (unsigned long long)block, - (unsigned long long)block, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_info(_("%s block %"PRIu64" (0x%"PRIx64"), part of inode " + "%"PRIu64" (0x%"PRIx64"), was already free.\n"), + btype, block, block, ip->i_addr, ip->i_addr); return META_IS_GOOD; } if (find_remove_dup(ip, block, btype, &removed_lastmeta)) { /* a dup */ @@ -101,12 +98,10 @@ static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t block, else *was_duplicate = 1; } - log_err( _("Not clearing duplicate reference in inode " - "at block #%llu (0x%llx) to block #%llu (0x%llx) " - "because it's referenced by another inode.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)block, (unsigned long long)block); + log_err(_("Not clearing duplicate reference in inode at block #%"PRIu64 + " (0x%"PRIx64") to block #%"PRIu64" (0x%"PRIx64") " + "because it's referenced by another inode.\n"), + ip->i_addr, ip->i_addr, block, block); } else { check_n_fix_bitmap(ip->i_sbd, ip->i_rgd, block, 0, GFS2_BLKST_FREE); @@ -218,15 +213,15 @@ static int del_eattr_generic(struct gfs2_inode *ip, uint64_t block, if (!ret) { *bh = bread(ip->i_sbd, block); if (!was_free) - ip->i_di.di_blocks--; + ip->i_blocks--; bmodified(ip->i_bh); } } /* Even if it's a duplicate reference, we want to eliminate the reference itself, and adjust di_blocks accordingly. */ - if (ip->i_di.di_eattr) { - if (block == ip->i_di.di_eattr) - ip->i_di.di_eattr = 0; + if (ip->i_eattr) { + if (block == ip->i_eattr) + ip->i_eattr = 0; bmodified(ip->i_bh); } return ret; @@ -308,7 +303,7 @@ int delete_eattr_extentry(struct gfs2_inode *ip, int i, uint64_t *ea_data_ptr, bmodified(leaf_bh); /* Endianness doesn't matter in this case because it's a single byte. */ - fsck_bitmap_set(ip, ip->i_di.di_eattr, + fsck_bitmap_set(ip, ip->i_eattr, _("extended attribute"), ip->i_sbd->gfs1 ? GFS2_BLKST_DINODE : GFS2_BLKST_USED); diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c index 6251ba90..30b79bc0 100644 --- a/gfs2/fsck/fs_recovery.c +++ b/gfs2/fsck/fs_recovery.c @@ -399,7 +399,7 @@ static int foreach_descriptor(struct gfs2_inode *ip, unsigned int start, static int check_journal_seq_no(struct gfs2_inode *ip, int fix) { int error = 0, wrapped = 0; - uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize; + uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize; uint32_t blk; struct lgfs2_log_header lh; uint64_t highest_seq = 0, lowest_seq = 0, prev_seq = 0; @@ -609,7 +609,7 @@ out: reinit: if (query( _("Do you want to clear the journal instead? (y/n)"))) { error = write_journal(sdp->md.journal[j], sdp->bsize, - sdp->md.journal[j]->i_di.di_size / + sdp->md.journal[j]->i_size / sdp->sd_sb.sb_bsize); log_err(_("jid=%u: journal was cleared.\n"), j); } else { @@ -624,9 +624,8 @@ static int rangecheck_jblock(struct gfs2_inode *ip, uint64_t block) { if((block > ip->i_sbd->fssize) || (block <= LGFS2_SB_ADDR(ip->i_sbd))) { log_info( _("Bad block pointer (out of range) found in " - "journal inode %lld (0x%llx).\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + "journal inode %"PRIu64" (0x%"PRIx64").\n"), + ip->i_addr, ip->i_addr); return META_ERROR; /* Exits check_metatree quicker */ } return META_IS_GOOD; @@ -647,14 +646,11 @@ static int rangecheck_jmeta(struct iptr iptr, struct gfs2_buffer_head **bh, int *bh = bread(ip->i_sbd, block); *is_valid = (gfs2_check_meta((*bh)->b_data, GFS2_METATYPE_IN) == 0); if (!(*is_valid)) { - log_err( _("Journal at block %lld (0x%llx) has a bad " - "indirect block pointer %lld (0x%llx) " + log_err( _("Journal at block %"PRIu64" (0x%"PRIx64") has a bad " + "indirect block pointer %"PRIu64" (0x%"PRIx64") " "(points to something that is not an " "indirect block).\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)block, - (unsigned long long)block); + ip->i_addr, ip->i_addr, block, block); brelse(*bh); *bh = NULL; return META_SKIP_FURTHER; @@ -717,8 +713,7 @@ int replay_journals(struct gfs2_sbd *sdp, int preen, int force_check, continue; } if (!error) { - uint64_t jsize = sdp->md.journal[i]->i_di.di_size / - (1024 * 1024); + uint64_t jsize = sdp->md.journal[i]->i_size / (1024 * 1024);
if (sdp->jsize == GFS2_DEFAULT_JSIZE && jsize && jsize != sdp->jsize) @@ -769,11 +764,11 @@ int ji_update(struct gfs2_sbd *sdp) If per_node is missing or damaged, we have to trust jindex has the correct number of entries. */ if (sdp->gfs1) - sdp->md.journals = ip->i_di.di_size / sizeof(struct gfs_jindex); + sdp->md.journals = ip->i_size / sizeof(struct gfs_jindex); else if (sdp->md.pinode) /* if per_node was read in properly */ - sdp->md.journals = (sdp->md.pinode->i_di.di_entries - 2) / 3; + sdp->md.journals = (sdp->md.pinode->i_entries - 2) / 3; else - sdp->md.journals = ip->i_di.di_entries - 2; + sdp->md.journals = ip->i_entries - 2;
if (!(sdp->md.journal = calloc(sdp->md.journals, sizeof(struct gfs2_inode *)))) { @@ -911,7 +906,7 @@ int init_jindex(struct gfs2_sbd *sdp, int allow_ji_rebuild) int error;
log_debug(_("Checking the integrity of the journal index.\n")); - if (sdp->md.jiinode->i_di.di_flags & GFS2_DIF_EXHASH) + if (sdp->md.jiinode->i_flags & GFS2_DIF_EXHASH) error = check_leaf_blks(sdp->md.jiinode, &jindex_check_fxns); else diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c index 1a6db6ec..3f2c088b 100644 --- a/gfs2/fsck/initialize.c +++ b/gfs2/fsck/initialize.c @@ -301,10 +301,9 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct rgrp_tree *rgd, if (!gfs2_check_meta(bh->b_data, GFS2_METATYPE_DI)) { struct gfs2_inode *ip = fsck_inode_get(sdp, rgd, bh); - if (ip->i_di.di_blocks > 1) { - blks_2free += - ip->i_di.di_blocks - 1; - log_info(_("%lld blocks " + if (ip->i_blocks > 1) { + blks_2free += ip->i_blocks - 1; + log_info(_("%llu blocks " "(total) may need " "to be freed in " "pass 5.\n"), @@ -492,14 +491,14 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.jiinode) { inum.no_formal_ino = sdp->md.next_inum++; - inum.no_addr = fix_md.jiinode->i_di.di_num.no_addr; + inum.no_addr = fix_md.jiinode->i_addr; err = dir_add(sdp->master_dir, "jindex", 6, &inum, IF2DT(S_IFDIR | 0700)); if (err) { log_crit(_("Error %d adding jindex directory\n"), errno); exit(FSCK_ERROR); } - sdp->master_dir->i_di.di_nlink++; + sdp->master_dir->i_nlink++; } else { err = build_jindex(sdp); if (err) { @@ -510,7 +509,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.pinode) { inum.no_formal_ino = sdp->md.next_inum++; - inum.no_addr = fix_md.pinode->i_di.di_num.no_addr; + inum.no_addr = fix_md.pinode->i_addr; err = dir_add(sdp->master_dir, "per_node", 8, &inum, IF2DT(S_IFDIR | 0700)); if (err) { @@ -518,7 +517,7 @@ static int rebuild_master(struct gfs2_sbd *sdp) errno); exit(FSCK_ERROR); } - sdp->master_dir->i_di.di_nlink++; + sdp->master_dir->i_nlink++; } else { err = build_per_node(sdp); if (err) { @@ -530,7 +529,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.inum) { inum.no_formal_ino = sdp->md.next_inum++; - inum.no_addr = fix_md.inum->i_di.di_num.no_addr; + inum.no_addr = fix_md.inum->i_addr; err = dir_add(sdp->master_dir, "inum", 4, &inum, IF2DT(S_IFREG | 0600)); if (err) { @@ -548,7 +547,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.statfs) { inum.no_formal_ino = sdp->md.next_inum++; - inum.no_addr = fix_md.statfs->i_di.di_num.no_addr; + inum.no_addr = fix_md.statfs->i_addr; err = dir_add(sdp->master_dir, "statfs", 6, &inum, IF2DT(S_IFREG | 0600)); if (err) { @@ -566,7 +565,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.riinode) { inum.no_formal_ino = sdp->md.next_inum++; - inum.no_addr = fix_md.riinode->i_di.di_num.no_addr; + inum.no_addr = fix_md.riinode->i_addr; err = dir_add(sdp->master_dir, "rindex", 6, &inum, IF2DT(S_IFREG | 0600)); if (err) { @@ -583,7 +582,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
if (fix_md.qinode) { inum.no_formal_ino = sdp->md.next_inum++; - inum.no_addr = fix_md.qinode->i_di.di_num.no_addr; + inum.no_addr = fix_md.qinode->i_addr; err = dir_add(sdp->master_dir, "quota", 5, &inum, IF2DT(S_IFREG | 0600)); if (err) { @@ -850,8 +849,8 @@ static int init_system_inodes(struct gfs2_sbd *sdp) } /* Read inum entry into buffer */ err = gfs2_readi(sdp->md.inum, &inumbuf, 0, - sdp->md.inum->i_di.di_size); - if (err != sdp->md.inum->i_di.di_size) { + sdp->md.inum->i_size); + if (err != sdp->md.inum->i_size) { log_crit(_("Error %d reading system inum inode. " "Aborting.\n"), err); goto fail; @@ -902,12 +901,12 @@ static int init_system_inodes(struct gfs2_sbd *sdp) } do_init_statfs(sdp); } - if (sdp->md.statfs->i_di.di_size) { - buf = malloc(sdp->md.statfs->i_di.di_size); + if (sdp->md.statfs->i_size) { + buf = malloc(sdp->md.statfs->i_size); if (buf) { err = gfs2_readi(sdp->md.statfs, buf, 0, - sdp->md.statfs->i_di.di_size); - if (err != sdp->md.statfs->i_di.di_size) { + sdp->md.statfs->i_size); + if (err != sdp->md.statfs->i_size) { log_crit(_("Error %d reading statfs file. " "Aborting.\n"), err); free(buf); @@ -984,9 +983,9 @@ static int init_system_inodes(struct gfs2_sbd *sdp) * A real dinode will be located at the block number in its no_addr. * A journal-copy will be at a different block (inside the journal). */ -static int is_journal_copy(struct gfs2_inode *ip, struct gfs2_buffer_head *bh) +static int is_journal_copy(struct gfs2_inode *ip) { - if (ip->i_di.di_num.no_addr == bh->b_blocknr) + if (ip->i_addr == ip->i_bh->b_blocknr) return 0; return 1; /* journal copy */ } @@ -1001,47 +1000,40 @@ static int is_journal_copy(struct gfs2_inode *ip, struct gfs2_buffer_head *bh) * the per_node directory will have a ".." entry that will lead us to * the master dinode if it's been destroyed. */ -static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di, - struct gfs2_buffer_head *bh) +static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip) { - struct gfs2_inode *ip, *child_ip; + struct gfs2_inode *child_ip; struct gfs2_inum inum; int error;
- if (di->di_num.no_formal_ino == 2) { + if (ip->i_formal_ino == 2) { if (sdp->sd_sb.sb_master_dir.no_addr) return; log_warn(_("Found system master directory at: 0x%"PRIx64".\n"), - di->di_num.no_addr); - sdp->sd_sb.sb_master_dir.no_addr = di->di_num.no_addr; + ip->i_addr); + sdp->sd_sb.sb_master_dir.no_addr = ip->i_addr; return; } - ip = lgfs2_inode_read(sdp, di->di_num.no_addr); - if (ip == NULL) { - log_crit(_("Error reading inode: %s\n"), strerror(errno)); - return; - } - if ((!sdp->gfs1 && di->di_num.no_formal_ino == 3) || - (sdp->gfs1 && (di->di_flags & GFS2_DIF_JDATA) && - (di->di_size % sizeof(struct gfs_jindex) == 0))) { - if (fix_md.jiinode || is_journal_copy(ip, bh)) + if ((!sdp->gfs1 && ip->i_formal_ino == 3) || + (sdp->gfs1 && (ip->i_flags & GFS2_DIF_JDATA) && + (ip->i_size % sizeof(struct gfs_jindex) == 0))) { + if (fix_md.jiinode || is_journal_copy(ip)) goto out_discard_ip; - log_warn(_("Found system jindex file at: 0x%"PRIx64"\n"), - di->di_num.no_addr); + log_warn(_("Found system jindex file at: 0x%"PRIx64"\n"), ip->i_addr); fix_md.jiinode = ip; - } else if (!sdp->gfs1 && is_dir(di, sdp->gfs1)) { + } else if (!sdp->gfs1 && is_dir(ip, sdp->gfs1)) { /* Check for a jindex dir entry. Only one system dir has a jindex: master */ gfs2_lookupi(ip, "jindex", 6, &child_ip); if (child_ip) { - if (fix_md.jiinode || is_journal_copy(ip, bh)) { + if (fix_md.jiinode || is_journal_copy(ip)) { inode_put(&child_ip); goto out_discard_ip; } fix_md.jiinode = child_ip; - sdp->sd_sb.sb_master_dir.no_addr = di->di_num.no_addr; + sdp->sd_sb.sb_master_dir.no_addr = ip->i_addr; log_warn(_("Found system master directory at: 0x%"PRIx64"\n"), - di->di_num.no_addr); + ip->i_addr); return; }
@@ -1050,10 +1042,10 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di, gfs2_lookupi(ip, "statfs_change0", 14, &child_ip); if (child_ip) { inode_put(&child_ip); - if (fix_md.pinode || is_journal_copy(ip, bh)) + if (fix_md.pinode || is_journal_copy(ip)) goto out_discard_ip; log_warn(_("Found system per_node directory at: 0x%"PRIx64"\n"), - ip->i_di.di_num.no_addr); + ip->i_addr); fix_md.pinode = ip; error = dir_search(ip, "..", 2, NULL, &inum); if (!error && inum.no_addr) { @@ -1064,35 +1056,30 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di, } return; } - log_debug(_("Unknown system directory at block 0x%"PRIx64"\n"), - di->di_num.no_addr); + log_debug(_("Unknown system directory at block 0x%"PRIx64"\n"), ip->i_addr); goto out_discard_ip; - } else if (!sdp->gfs1 && di->di_size == 8) { - if (fix_md.inum || is_journal_copy(ip, bh)) + } else if (!sdp->gfs1 && ip->i_size == 8) { + if (fix_md.inum || is_journal_copy(ip)) goto out_discard_ip; fix_md.inum = ip; - log_warn(_("Found system inum file at: 0x%"PRIx64"\n"), - di->di_num.no_addr); - } else if (di->di_size == 24) { - if (fix_md.statfs || is_journal_copy(ip, bh)) + log_warn(_("Found system inum file at: 0x%"PRIx64"\n"), ip->i_addr); + } else if (ip->i_size == 24) { + if (fix_md.statfs || is_journal_copy(ip)) goto out_discard_ip; fix_md.statfs = ip; - log_warn(_("Found system statfs file at: 0x%"PRIx64"\n"), - di->di_num.no_addr); - } else if ((di->di_size % 96) == 0) { - if (fix_md.riinode || is_journal_copy(ip, bh)) + log_warn(_("Found system statfs file at: 0x%"PRIx64"\n"), ip->i_addr); + } else if ((ip->i_size % 96) == 0) { + if (fix_md.riinode || is_journal_copy(ip)) goto out_discard_ip; fix_md.riinode = ip; - log_warn(_("Found system rindex file at: 0x%"PRIx64"\n"), - di->di_num.no_addr); - } else if (!fix_md.qinode && di->di_size >= 176 && - di->di_num.no_formal_ino >= 12 && - di->di_num.no_formal_ino <= 100) { - if (is_journal_copy(ip, bh)) + log_warn(_("Found system rindex file at: 0x%"PRIx64"\n"), ip->i_addr); + } else if (!fix_md.qinode && ip->i_size >= 176 && + ip->i_formal_ino >= 12 && + ip->i_formal_ino <= 100) { + if (is_journal_copy(ip)) goto out_discard_ip; fix_md.qinode = ip; - log_warn(_("Found system quota file at: 0x%"PRIx64"\n"), - di->di_num.no_addr); + log_warn(_("Found system quota file at: 0x%"PRIx64"\n"), ip->i_addr); } else { out_discard_ip: inode_put(&ip); @@ -1103,58 +1090,49 @@ out_discard_ip: * peruse_user_dinode - process a user dinode trying to find the root directory * */ -static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di, - struct gfs2_buffer_head *bh) +static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_inode *ip) { - struct gfs2_inode *ip, *parent_ip; + struct gfs2_inode *parent_ip; struct gfs2_inum inum; int error;
if (sdp->sd_sb.sb_root_dir.no_addr) /* if we know the root dinode */ return; /* we don't need to find the root */ - if (!is_dir(di, sdp->gfs1)) /* if this isn't a directory */ + if (!is_dir(ip, sdp->gfs1)) /* if this isn't a directory */ return; /* it can't lead us to the root anyway */
- if (di->di_num.no_formal_ino == 1) { + if (ip->i_formal_ino == 1) { struct gfs2_buffer_head *root_bh;
- if (di->di_num.no_addr == bh->b_blocknr) { + if (ip->i_addr == ip->i_bh->b_blocknr) { log_warn(_("Found the root directory at: 0x%"PRIx64".\n"), - di->di_num.no_addr); - sdp->sd_sb.sb_root_dir.no_addr = di->di_num.no_addr; + ip->i_addr); + sdp->sd_sb.sb_root_dir.no_addr = ip->i_addr; return; } log_warn(_("The root dinode should be at block 0x%"PRIx64" but it " "seems to be destroyed.\n"), - di->di_num.no_addr); + ip->i_addr); log_warn(_("Found a copy of the root directory in a journal " "at block: 0x%"PRIx64".\n"), - bh->b_blocknr); - if (!query(_("Do you want to replace the root dinode from the " - "copy? (y/n)"))) { + ip->i_bh->b_blocknr); + if (!query(_("Do you want to replace the root dinode from the copy? (y/n)"))) { log_err(_("Damaged root dinode not fixed.\n")); return; } - root_bh = bread(sdp, di->di_num.no_addr); - memcpy(root_bh->b_data, bh->b_data, sdp->bsize); + root_bh = bread(sdp, ip->i_addr); + memcpy(root_bh->b_data, ip->i_bh->b_data, sdp->bsize); bmodified(root_bh); brelse(root_bh); log_warn(_("Root directory copied from the journal.\n")); return; } - ip = lgfs2_inode_read(sdp, di->di_num.no_addr); - if (ip == NULL) { - log_crit(_("Error reading inode: %s\n"), strerror(errno)); - return; - } while (ip) { gfs2_lookupi(ip, "..", 2, &parent_ip); - if (parent_ip && parent_ip->i_di.di_num.no_addr == - ip->i_di.di_num.no_addr) { + if (parent_ip && parent_ip->i_addr == ip->i_addr) { log_warn(_("Found the root directory at: 0x%"PRIx64"\n"), - ip->i_di.di_num.no_addr); - sdp->sd_sb.sb_root_dir.no_addr = - ip->i_di.di_num.no_addr; + ip->i_addr); + sdp->sd_sb.sb_root_dir.no_addr = ip->i_addr; inode_put(&parent_ip); inode_put(&ip); return; @@ -1250,7 +1228,7 @@ static int peruse_metadata(struct gfs2_sbd *sdp, uint64_t startblock) { uint64_t blk, max_rg_size; struct gfs2_buffer_head *bh; - struct gfs2_dinode di; + struct gfs2_inode *ip;
max_rg_size = 2147483648ull / sdp->bsize; /* Max RG size is 2GB. 2G / bsize. */ @@ -1260,12 +1238,12 @@ static int peruse_metadata(struct gfs2_sbd *sdp, uint64_t startblock) brelse(bh); continue; } - gfs2_dinode_in(&di, bh->b_data); - if (di.di_flags & GFS2_DIF_SYSTEM) - peruse_system_dinode(sdp, &di, bh); + ip = lgfs2_inode_get(sdp, bh); + ip->bh_owned = 1; /* inode_put() will free the bh */ + if (ip->i_flags & GFS2_DIF_SYSTEM) + peruse_system_dinode(sdp, ip); else - peruse_user_dinode(sdp, &di, bh); - brelse(bh); + peruse_user_dinode(sdp, ip); } return 0; } @@ -1331,8 +1309,7 @@ static int sb_repair(struct gfs2_sbd *sdp) (unsigned long long)possible_root); sdp->sd_sb.sb_root_dir.no_addr = possible_root; sdp->md.rooti = lgfs2_inode_read(sdp, possible_root); - if (!sdp->md.rooti || - sdp->md.rooti->i_di.di_header.mh_magic != GFS2_MAGIC) { + if (!sdp->md.rooti || sdp->md.rooti->i_magic != GFS2_MAGIC) { struct gfs2_buffer_head *bh = NULL;
log_err(_("The root dinode block is destroyed.\n")); @@ -1365,8 +1342,7 @@ static int sb_repair(struct gfs2_sbd *sdp) log_crit(_("Error reading master inode: %s\n"), strerror(errno)); return -1; } - sdp->master_dir->i_di.di_num.no_addr = - sdp->sd_sb.sb_master_dir.no_addr; + sdp->master_dir->i_addr = sdp->sd_sb.sb_master_dir.no_addr; log_info(_("Found the root directory at: 0x%"PRIx64"\n"), sdp->sd_sb.sb_root_dir.no_addr); sdp->md.rooti = lgfs2_inode_read(sdp, @@ -1378,8 +1354,10 @@ static int sb_repair(struct gfs2_sbd *sdp) lgfs2_sb_init(&sb, sdp->bsize, GFS2_FORMAT_FS); strcpy(sb.sb_lockproto, GFS2_DEFAULT_LOCKPROTO); strcpy(sb.sb_locktable, "unknown"); - sb.sb_master_dir = sdp->master_dir->i_di.di_num; - sb.sb_root_dir = sdp->md.rooti->i_di.di_num; + sb.sb_master_dir.no_addr = sdp->master_dir->i_addr; + sb.sb_master_dir.no_formal_ino = sdp->master_dir->i_formal_ino; + sb.sb_root_dir.no_addr = sdp->md.rooti->i_addr; + sb.sb_root_dir.no_formal_ino = sdp->md.rooti->i_formal_ino; lgfs2_sb_write(&sb, sdp->device_fd, sdp->bsize); inode_put(&sdp->md.rooti); inode_put(&sdp->master_dir); @@ -1493,8 +1471,7 @@ static int reconstruct_single_journal(struct gfs2_sbd *sdp, int jnum, lh.lh_header.mh_format = GFS2_FORMAT_LH; lh.lh_header.__pad0 = 0x101674; /* mh_generation */ lh.lh_flags = GFS2_LOG_HEAD_UNMOUNT; - lh.lh_first = sdp->md.journal[jnum]->i_di.di_num.no_addr + - (seg * sbd1->sb_seg_size); + lh.lh_first = sdp->md.journal[jnum]->i_addr + (seg * sbd1->sb_seg_size); lh.lh_sequence = sequence;
bh = bget(sdp, lh.lh_first * sdp->bsize); @@ -1711,9 +1688,9 @@ int initialize(struct gfs2_sbd *sdp, int force_check, int preen, sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_sb.sb_master_dir.no_addr); if (!sdp->gfs1 && - (sdp->master_dir->i_di.di_header.mh_magic != GFS2_MAGIC || - sdp->master_dir->i_di.di_header.mh_type != GFS2_METATYPE_DI || - !sdp->master_dir->i_di.di_size)) { + (sdp->master_dir->i_magic != GFS2_MAGIC || + sdp->master_dir->i_type != GFS2_METATYPE_DI || + !sdp->master_dir->i_size)) { inode_put(&sdp->master_dir); rebuild_master(sdp); sdp->master_dir = lgfs2_inode_read(sdp, diff --git a/gfs2/fsck/link.c b/gfs2/fsck/link.c index 08118e8a..1c5ec3d2 100644 --- a/gfs2/fsck/link.c +++ b/gfs2/fsck/link.c @@ -40,30 +40,34 @@ int set_di_nlink(struct gfs2_inode *ip) struct inode_info *ii; struct dir_info *di;
- if (is_dir(&ip->i_di, ip->i_sbd->gfs1)) { - di = dirtree_find(ip->i_di.di_num.no_addr); + if (is_dir(ip, ip->i_sbd->gfs1)) { + di = dirtree_find(ip->i_addr); if (di == NULL) { - log_err(_("Error: directory %lld (0x%llx) is not " + log_err(_("Error: directory %"PRIu64" (0x%"PRIx64") is not " "in the dir_tree (set).\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + ip->i_addr, ip->i_addr); return -1; } - di->di_nlink = ip->i_di.di_nlink; + di->di_nlink = ip->i_nlink; return 0; } - if (ip->i_di.di_nlink == 1) { - link1_set(&nlink1map, ip->i_di.di_num.no_addr, 1); + if (ip->i_nlink == 1) { + link1_set(&nlink1map, ip->i_addr, 1); return 0; } /*log_debug( _("Setting link count to %u for %" PRIu64 " (0x%" PRIx64 ")\n"), count, inode_no, inode_no);*/ /* If the list has entries, look for one that matches inode_no */ - ii = inodetree_find(ip->i_di.di_num.no_addr); - if (!ii) - ii = inodetree_insert(ip->i_di.di_num); + ii = inodetree_find(ip->i_addr); + if (!ii) { + struct gfs2_inum no = { + .no_addr = ip->i_addr, + .no_formal_ino = ip->i_formal_ino + }; + ii = inodetree_insert(no); + } if (ii) - ii->di_nlink = ip->i_di.di_nlink; + ii->di_nlink = ip->i_nlink; else return -1; return 0; @@ -81,7 +85,7 @@ int incr_link_count(struct gfs2_inum no, struct gfs2_inode *ip, const char *why) { struct inode_info *ii = NULL; - uint64_t referenced_from = ip ? ip->i_di.di_num.no_addr : 0; + uint64_t referenced_from = ip ? ip->i_addr : 0; struct dir_info *di; struct gfs2_inode *link_ip;
@@ -112,7 +116,7 @@ int incr_link_count(struct gfs2_inum no, struct gfs2_inode *ip,
link_ip = fsck_load_inode(ip->i_sbd, no.no_addr); /* Check formal ino against dinode before adding to inode tree. */ - if (no.no_formal_ino != link_ip->i_di.di_num.no_formal_ino) { + if (no.no_formal_ino != link_ip->i_formal_ino) { fsck_inode_put(&link_ip); return INCR_LINK_INO_MISMATCH; /* inode mismatch */ } @@ -132,7 +136,8 @@ int incr_link_count(struct gfs2_inum no, struct gfs2_inode *ip, fsck_inode_put(&link_ip); return INCR_LINK_BAD; } - ii->di_num = link_ip->i_di.di_num; + ii->di_num.no_addr = link_ip->i_addr; + ii->di_num.no_formal_ino = link_ip->i_formal_ino; fsck_inode_put(&link_ip); ii->di_nlink = 1; /* Must be 1 or it wouldn't have gotten into the nlink1map */ diff --git a/gfs2/fsck/lost_n_found.c b/gfs2/fsck/lost_n_found.c index ebe616af..59df4c05 100644 --- a/gfs2/fsck/lost_n_found.c +++ b/gfs2/fsck/lost_n_found.c @@ -20,43 +20,38 @@
static void add_dotdot(struct gfs2_inode *ip) { - struct dir_info *di; struct gfs2_sbd *sdp = ip->i_sbd; + struct dir_info *di; + struct gfs2_inum no; int err;
- log_info( _("Adding .. entry to directory %llu (0x%llx) pointing back " - "to lost+found\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_info(_("Adding .. entry to directory %"PRIu64" (0x%"PRIx64") pointing back to lost+found\n"), + ip->i_addr, ip->i_addr);
/* If there's a pre-existing .. directory entry, we have to back out the links. */ - di = dirtree_find(ip->i_di.di_num.no_addr); + di = dirtree_find(ip->i_addr); if (di && valid_block(sdp, di->dotdot_parent.no_addr)) { struct gfs2_inode *dip;
- log_debug(_("Directory (0x%llx) already had a " - "".." link to (0x%llx).\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)di->dotdot_parent.no_addr); + log_debug(_("Directory (0x%"PRIx64") already had a '..' link to (0x%"PRIx64").\n"), + ip->i_addr, di->dotdot_parent.no_addr); dip = fsck_load_inode(sdp, di->dotdot_parent.no_addr); - if (dip->i_di.di_num.no_formal_ino == - di->dotdot_parent.no_formal_ino) { - decr_link_count(di->dotdot_parent.no_addr, - ip->i_di.di_num.no_addr, sdp->gfs1, + if (dip->i_formal_ino == di->dotdot_parent.no_formal_ino) { + decr_link_count(di->dotdot_parent.no_addr, ip->i_addr, sdp->gfs1, _(".. unlinked, moving to lost+found")); - if (dip->i_di.di_nlink > 0) { - dip->i_di.di_nlink--; + if (dip->i_nlink > 0) { + dip->i_nlink--; set_di_nlink(dip); /* keep inode tree in sync */ log_debug(_("Decrementing its links to %d\n"), - dip->i_di.di_nlink); + dip->i_nlink); bmodified(dip->i_bh); - } else if (!dip->i_di.di_nlink) { + } else if (!dip->i_nlink) { log_debug(_("Its link count is zero.\n")); } else { - log_debug(_("Its link count is %d! Changing " - "it to 0.\n"), dip->i_di.di_nlink); - dip->i_di.di_nlink = 0; + log_debug(_("Its link count is %d! Changing it to 0.\n"), + dip->i_nlink); + dip->i_nlink = 0; set_di_nlink(dip); /* keep inode tree in sync */ bmodified(dip->i_bh); } @@ -64,32 +59,31 @@ static void add_dotdot(struct gfs2_inode *ip) log_debug(_("Directory (0x%"PRIx64")'s link to parent " "(0x%"PRIx64") had a formal inode discrepancy: " "was 0x%"PRIx64", expected 0x%"PRIx64"\n"), - ip->i_di.di_num.no_addr, - di->dotdot_parent.no_addr, + ip->i_addr, di->dotdot_parent.no_addr, di->dotdot_parent.no_formal_ino, - dip->i_di.di_num.no_formal_ino); + dip->i_formal_ino); log_debug(_("The parent directory was not changed.\n")); } fsck_inode_put(&dip); di = NULL; } else { if (di) - log_debug(_("Couldn't find a valid ".." entry " - "for orphan directory (0x%llx): " - "'..' = 0x%llx\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)di->dotdot_parent.no_addr); + log_debug(_("Couldn't find a valid '..' entry " + "for orphan directory (0x%"PRIx64"): " + "'..' = 0x%"PRIx64"\n"), + ip->i_addr, di->dotdot_parent.no_addr); else - log_debug(_("Couldn't find directory (0x%llx) " + log_debug(_("Couldn't find directory (0x%"PRIx64") " "in directory tree.\n"), - (unsigned long long)ip->i_di.di_num.no_addr); + ip->i_addr); } if (gfs2_dirent_del(ip, "..", 2)) log_warn( _("add_inode_to_lf: Unable to remove " "".." directory entry.\n"));
- err = dir_add(ip, "..", 2, &(lf_dip->i_di.di_num), - (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR)); + no.no_addr = lf_dip->i_addr; + no.no_formal_ino = lf_dip->i_formal_ino; + err = dir_add(ip, "..", 2, &no, (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR)); if (err) { log_crit(_("Error adding .. directory: %s\n"), strerror(errno)); @@ -107,7 +101,7 @@ void make_sure_lf_exists(struct gfs2_inode *ip) if (lf_dip) return;
- root_entries = sdp->md.rooti->i_di.di_entries; + root_entries = sdp->md.rooti->i_entries; log_info( _("Locating/Creating lost+found directory\n"));
/* if this is gfs1, we have to trick createi into using @@ -132,32 +126,38 @@ void make_sure_lf_exists(struct gfs2_inode *ip) them in sync so that pass4 can detect and fix any descrepancies. */ set_di_nlink(sdp->md.rooti);
- if (sdp->md.rooti->i_di.di_entries > root_entries) { + if (sdp->md.rooti->i_entries > root_entries) { + struct gfs2_inum no = { + .no_addr = lf_dip->i_addr, + .no_formal_ino = lf_dip->i_formal_ino + }; lf_was_created = 1; /* This is a new lost+found directory, so set its block type and increment link counts for the directories */ /* FIXME: i'd feel better about this if fs_mkdir returned whether it created a new directory or just found an old one, and we used that instead of the bitmap_type to run this */ - dirtree_insert(lf_dip->i_di.di_num); + dirtree_insert(no); /* Set the bitmap AFTER the dirtree insert so that function check_n_fix_bitmap will realize it's a dinode and adjust the rgrp counts properly. */ - fsck_bitmap_set(ip, lf_dip->i_di.di_num.no_addr, - _("lost+found dinode"), GFS2_BLKST_DINODE); + fsck_bitmap_set(ip, lf_dip->i_addr, _("lost+found dinode"), GFS2_BLKST_DINODE); /* root inode links to lost+found */ - incr_link_count(sdp->md.rooti->i_di.di_num, lf_dip, _("root")); + no.no_addr = sdp->md.rooti->i_addr; + no.no_formal_ino = sdp->md.rooti->i_formal_ino; + incr_link_count(no, lf_dip, _("root")); /* lost+found link for '.' from itself */ - incr_link_count(lf_dip->i_di.di_num, lf_dip, "".""); + no.no_addr = lf_dip->i_addr; + no.no_formal_ino = lf_dip->i_formal_ino; + incr_link_count(no, lf_dip, "".""); /* lost+found link for '..' back to root */ - incr_link_count(lf_dip->i_di.di_num, sdp->md.rooti, ""..""); + incr_link_count(no, sdp->md.rooti, ""..""); if (sdp->gfs1) - lf_dip->i_di.__pad1 = GFS_FILE_DIR; + lf_dip->i_pad1 = GFS_FILE_DIR; } - log_info( _("lost+found directory is dinode %lld (0x%llx)\n"), - (unsigned long long)lf_dip->i_di.di_num.no_addr, - (unsigned long long)lf_dip->i_di.di_num.no_addr); - di = dirtree_find(lf_dip->i_di.di_num.no_addr); + log_info(_("lost+found directory is dinode %"PRIu64" (0x%"PRIx64")\n"), + lf_dip->i_addr, lf_dip->i_addr); + di = dirtree_find(lf_dip->i_addr); if (di) { log_info( _("Marking lost+found inode connected\n")); di->checked = 1; @@ -178,11 +178,12 @@ int add_inode_to_lf(struct gfs2_inode *ip){ char tmp_name[256]; __be32 inode_type; struct gfs2_sbd *sdp = ip->i_sbd; + struct gfs2_inum no; int err = 0; uint32_t mode;
make_sure_lf_exists(ip); - if (ip->i_di.di_num.no_addr == lf_dip->i_di.di_num.no_addr) { + if (ip->i_addr == lf_dip->i_addr) { log_err( _("Trying to add lost+found to itself...skipping")); return 0; } @@ -190,54 +191,47 @@ int add_inode_to_lf(struct gfs2_inode *ip){ if (sdp->gfs1) mode = gfs_to_gfs2_mode(ip); else - mode = ip->i_di.di_mode & S_IFMT; + mode = ip->i_mode & S_IFMT;
switch (mode) { case S_IFDIR: add_dotdot(ip); - sprintf(tmp_name, "lost_dir_%llu", - (unsigned long long)ip->i_di.di_num.no_addr); + sprintf(tmp_name, "lost_dir_%"PRIu64, ip->i_addr); inode_type = (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR); break; case S_IFREG: - sprintf(tmp_name, "lost_file_%llu", - (unsigned long long)ip->i_di.di_num.no_addr); + sprintf(tmp_name, "lost_file_%"PRIu64, ip->i_addr); inode_type = (sdp->gfs1 ? GFS_FILE_REG : DT_REG); break; case S_IFLNK: - sprintf(tmp_name, "lost_link_%llu", - (unsigned long long)ip->i_di.di_num.no_addr); + sprintf(tmp_name, "lost_link_%"PRIu64, ip->i_addr); inode_type = (sdp->gfs1 ? GFS_FILE_LNK : DT_LNK); break; case S_IFBLK: - sprintf(tmp_name, "lost_blkdev_%llu", - (unsigned long long)ip->i_di.di_num.no_addr); + sprintf(tmp_name, "lost_blkdev_%"PRIu64, ip->i_addr); inode_type = (sdp->gfs1 ? GFS_FILE_BLK : DT_BLK); break; case S_IFCHR: - sprintf(tmp_name, "lost_chrdev_%llu", - (unsigned long long)ip->i_di.di_num.no_addr); + sprintf(tmp_name, "lost_chrdev_%"PRIu64, ip->i_addr); inode_type = (sdp->gfs1 ? GFS_FILE_CHR : DT_CHR); break; case S_IFIFO: - sprintf(tmp_name, "lost_fifo_%llu", - (unsigned long long)ip->i_di.di_num.no_addr); + sprintf(tmp_name, "lost_fifo_%"PRIu64, ip->i_addr); inode_type = (sdp->gfs1 ? GFS_FILE_FIFO : DT_FIFO); break; case S_IFSOCK: - sprintf(tmp_name, "lost_socket_%llu", - (unsigned long long)ip->i_di.di_num.no_addr); + sprintf(tmp_name, "lost_socket_%"PRIu64, ip->i_addr); inode_type = (sdp->gfs1 ? GFS_FILE_SOCK : DT_SOCK); break; default: - sprintf(tmp_name, "lost_%llu", - (unsigned long long)ip->i_di.di_num.no_addr); + sprintf(tmp_name, "lost_%"PRIu64, ip->i_addr); inode_type = (sdp->gfs1 ? GFS_FILE_REG : DT_REG); break; }
- err = dir_add(lf_dip, tmp_name, strlen(tmp_name), &(ip->i_di.di_num), - inode_type); + no.no_addr = ip->i_addr; + no.no_formal_ino = ip->i_formal_ino; + err = dir_add(lf_dip, tmp_name, strlen(tmp_name), &no, inode_type); if (err) { log_crit(_("Error adding directory %s: %s\n"), tmp_name, strerror(errno)); @@ -245,15 +239,16 @@ int add_inode_to_lf(struct gfs2_inode *ip){ }
/* This inode is linked from lost+found */ - incr_link_count(ip->i_di.di_num, lf_dip, _("from lost+found")); + incr_link_count(no, lf_dip, _("from lost+found")); /* If it's a directory, lost+found is back-linked to it via .. */ - if (mode == S_IFDIR) - incr_link_count(lf_dip->i_di.di_num, ip, _("to lost+found")); - - log_notice( _("Added inode #%llu (0x%llx) to lost+found\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); - gfs2_dinode_out(&lf_dip->i_di, lf_dip->i_bh->b_data); + if (mode == S_IFDIR) { + no.no_addr = lf_dip->i_addr; + no.no_formal_ino = lf_dip->i_formal_ino; + incr_link_count(no, ip, _("to lost+found")); + } + log_notice(_("Added inode #%"PRIu64" (0x%"PRIx64") to lost+found\n"), + ip->i_addr, ip->i_addr); + lgfs2_dinode_out(lf_dip, lf_dip->i_bh->b_data); bwrite(lf_dip->i_bh); return 0; } diff --git a/gfs2/fsck/main.c b/gfs2/fsck/main.c index d424e075..e322b395 100644 --- a/gfs2/fsck/main.c +++ b/gfs2/fsck/main.c @@ -174,16 +174,15 @@ static int check_statfs(struct gfs2_sbd *sdp) uint64_t sc_dinodes; int count;
- if (sdp->gfs1 && !sdp->md.statfs->i_di.di_size) { + if (sdp->gfs1 && !sdp->md.statfs->i_size) { log_info("This GFS1 file system is not using fast_statfs.\n"); return 0; } /* Read the current statfs values */ - count = gfs2_readi(sdp->md.statfs, &sc, 0, - sdp->md.statfs->i_di.di_size); + count = gfs2_readi(sdp->md.statfs, &sc, 0, sdp->md.statfs->i_size); if (count != sizeof(struct gfs2_statfs_change)) { log_err(_("Failed to read statfs values (%d of %"PRIu64" read)\n"), - count, (uint64_t)sdp->md.statfs->i_di.di_size); + count, sdp->md.statfs->i_size); return FSCK_ERROR; } sc_total = be64_to_cpu(sc.sc_total); diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c index 8b721015..991f1175 100644 --- a/gfs2/fsck/metawalk.c +++ b/gfs2/fsck/metawalk.c @@ -178,9 +178,9 @@ int _fsck_bitmap_set(struct gfs2_inode *ip, uint64_t bblock, static const char *prev_caller = NULL;
if (print_level >= MSG_DEBUG) { - if ((ip->i_di.di_num.no_addr == prev_ino_addr) && + if ((ip->i_addr == prev_ino_addr) && (mark == prev_mark) && caller == prev_caller) { - log_info("(0x%llx) ", (unsigned long long)bblock); + log_info("(0x%"PRIx64") ", bblock); prevcount++; if (prevcount > 10) { log_info("\n"); @@ -188,30 +188,23 @@ int _fsck_bitmap_set(struct gfs2_inode *ip, uint64_t bblock, } /* I'm circumventing the log levels here on purpose to make the output easier to debug. */ - } else if (ip->i_di.di_num.no_addr == bblock) { + } else if (ip->i_addr == bblock) { if (prevcount) { log_info("\n"); prevcount = 0; } - printf( _("(%s:%d) %s inode found at block " - "(0x%llx): marking as '%s'\n"), caller, fline, - btype, - (unsigned long long)ip->i_di.di_num.no_addr, - block_type_string(mark)); - + printf(_("(%s:%d) %s inode found at block (0x%"PRIx64"): marking as '%s'\n"), + caller, fline, btype, ip->i_addr, block_type_string(mark)); } else { if (prevcount) { log_info("\n"); prevcount = 0; } - printf( _("(%s:%d) inode (0x%llx) references %s block" - " (0x%llx): marking as '%s'\n"), - caller, fline, - (unsigned long long)ip->i_di.di_num.no_addr, - btype, (unsigned long long)bblock, - block_type_string(mark)); + printf(_("(%s:%d) inode (0x%"PRIx64") references %s block" + " (0x%"PRIx64"): marking as '%s'\n"), + caller, fline, ip->i_addr, btype, bblock, block_type_string(mark)); } - prev_ino_addr = ip->i_di.di_num.no_addr; + prev_ino_addr = ip->i_addr; prev_mark = mark; prev_caller = caller; } @@ -243,24 +236,24 @@ struct gfs2_inode *fsck_system_inode(struct gfs2_sbd *sdp, uint64_t block) { int j;
- if (lf_dip && lf_dip->i_di.di_num.no_addr == block) + if (lf_dip && lf_dip->i_addr == block) return lf_dip; if (!sdp->gfs1) return is_system_inode(sdp, block);
- if (sdp->md.statfs && block == sdp->md.statfs->i_di.di_num.no_addr) + if (sdp->md.statfs && block == sdp->md.statfs->i_addr) return sdp->md.statfs; - if (sdp->md.jiinode && block == sdp->md.jiinode->i_di.di_num.no_addr) + if (sdp->md.jiinode && block == sdp->md.jiinode->i_addr) return sdp->md.jiinode; - if (sdp->md.riinode && block == sdp->md.riinode->i_di.di_num.no_addr) + if (sdp->md.riinode && block == sdp->md.riinode->i_addr) return sdp->md.riinode; - if (sdp->md.qinode && block == sdp->md.qinode->i_di.di_num.no_addr) + if (sdp->md.qinode && block == sdp->md.qinode->i_addr) return sdp->md.qinode; - if (sdp->md.rooti && block == sdp->md.rooti->i_di.di_num.no_addr) + if (sdp->md.rooti && block == sdp->md.rooti->i_addr) return sdp->md.rooti; for (j = 0; j < sdp->md.journals; j++) if (sdp->md.journal && sdp->md.journal[j] && - block == sdp->md.journal[j]->i_di.di_num.no_addr) + block == sdp->md.journal[j]->i_addr) return sdp->md.journal[j]; return NULL; } @@ -307,7 +300,7 @@ void fsck_inode_put(struct gfs2_inode **ip_in) struct gfs2_inode *ip = *ip_in; struct gfs2_inode *sysip;
- sysip = fsck_system_inode(ip->i_sbd, ip->i_di.di_num.no_addr); + sysip = fsck_system_inode(ip->i_sbd, ip->i_addr); if (!sysip) inode_put(ip_in); } @@ -430,14 +423,11 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh, if (de.de_rec_len < sizeof(struct gfs2_dirent) + de.de_name_len || (de.de_inum.no_formal_ino && !de.de_name_len && !first)) { - log_err( _("Directory block %llu (0x%llx" - "), entry %d of directory %llu " - "(0x%llx) is corrupt.\n"), - (unsigned long long)bh->b_blocknr, - (unsigned long long)bh->b_blocknr, - (*count) + 1, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Directory block %"PRIu64" (0x%"PRIx64"), " + "entry %d of directory %"PRIu64" (0x%"PRIx64") " + "is corrupt.\n"), + bh->b_blocknr, bh->b_blocknr, (*count) + 1, + ip->i_addr, ip->i_addr); if (query( _("Attempt to repair it? (y/n) "))) { if (dirent_repair(ip, bh, &de, dent, type, first)) { @@ -467,13 +457,11 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh, log_debug( _("First dirent is a sentinel (place holder).\n")); first = 0; } else { - log_err( _("Directory entry with inode number of " - "zero in leaf %llu (0x%llx) of " - "directory %llu (0x%llx)!\n"), - (unsigned long long)bh->b_blocknr, - (unsigned long long)bh->b_blocknr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Directory entry with inode number of " + "zero in leaf %"PRIu64" (0x%"PRIx64") of " + "directory %"PRIu64" (0x%"PRIx64")!\n"), + bh->b_blocknr, bh->b_blocknr, + ip->i_addr, ip->i_addr); if (query(_("Attempt to remove it? (y/n) "))) { dirblk_truncate(ip, prev, bh); log_err(_("The corrupt directory " @@ -509,13 +497,10 @@ static int check_entries(struct gfs2_inode *ip, struct gfs2_buffer_head *bh, }
if ((char *)dent + de.de_rec_len >= bh_end){ - log_debug( _("Last entry processed for %lld->%lld " - "(0x%llx->0x%llx), di_blocks=%llu.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)bh->b_blocknr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)bh->b_blocknr, - (unsigned long long)ip->i_di.di_blocks); + log_debug(_("Last entry processed for %"PRIu64"->%"PRIu64 + "(0x%"PRIx64"->0x%"PRIx64"), di_blocks=%"PRIu64".\n"), + ip->i_addr, bh->b_blocknr, ip->i_addr, + bh->b_blocknr, ip->i_blocks); break; }
@@ -542,16 +527,13 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass, uint32_t count = 0; struct gfs2_sbd *sdp = ip->i_sbd; const char *msg; - int di_depth = ip->i_di.di_depth; + int di_depth = ip->i_depth;
/* Make sure the block number is in range. */ if (!valid_block_ip(ip, *leaf_no)) { - log_err( _("Leaf block #%llu (0x%llx) is out of range for " - "directory #%llu (0x%llx) at index %d (0x%x).\n"), - (unsigned long long)*leaf_no, - (unsigned long long)*leaf_no, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, + log_err( _("Leaf block #%"PRIu64" (0x%"PRIx64") is out of range for " + "directory #%"PRIu64" (0x%"PRIx64") at index %d (0x%x).\n"), + *leaf_no, *leaf_no, ip->i_addr, ip->i_addr, lindex, lindex); msg = _("that is out of range"); goto bad_leaf; @@ -595,17 +577,14 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass,
/* Make sure it's really a leaf. */ if (leaf->lf_header.mh_type != GFS2_METATYPE_LF) { - log_err( _("Inode %llu (0x%llx) points to bad leaf %llu" - " (0x%llx).\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)*leaf_no, - (unsigned long long)*leaf_no); + log_err(_("Inode %"PRIu64" (0x%"PRIx64") points to bad leaf %"PRIu64 + " (0x%"PRIx64").\n"), + ip->i_addr, ip->i_addr, *leaf_no, *leaf_no); msg = _("that is not a leaf"); goto bad_leaf; }
- if (pass->check_dentry && is_dir(&ip->i_di, sdp->gfs1)) { + if (pass->check_dentry && is_dir(ip, sdp->gfs1)) { error = check_entries(ip, lbh, DIR_EXHASH, &count, lindex, pass);
@@ -626,14 +605,11 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass, lbh = bread(sdp, *leaf_no); gfs2_leaf_in(leaf, lbh->b_data); if (count != leaf->lf_entries) { - log_err( _("Leaf %llu (0x%llx) entry count in " - "directory %llu (0x%llx) does not match " + log_err(_("Leaf %"PRIu64" (0x%"PRIx64") entry count in " + "directory %"PRIu64" (0x%"PRIx64") does not match " "number of entries found - is %u, found %u\n"), - (unsigned long long)*leaf_no, - (unsigned long long)*leaf_no, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - leaf->lf_entries, count); + *leaf_no, *leaf_no, ip->i_addr, ip->i_addr, + leaf->lf_entries, count); if (query( _("Update leaf entry count? (y/n) "))) { leaf->lf_entries = count; gfs2_leaf_out(leaf, lbh->b_data); @@ -645,15 +621,12 @@ int check_leaf(struct gfs2_inode *ip, int lindex, struct metawalk_fxns *pass, } } out: - if (di_depth < ip->i_di.di_depth) { - log_debug(_("Depth of directory %lld (0x%llx) changed from " + if (di_depth < ip->i_depth) { + log_debug(_("Depth of directory %"PRIu64" (0x%"PRIx64") changed from " "%d to %d; adjusting ref_count from %d to %d\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - di_depth, ip->i_di.di_depth, - *ref_count, - (*ref_count) << (ip->i_di.di_depth - di_depth)); - (*ref_count) <<= (ip->i_di.di_depth - di_depth); + ip->i_addr, ip->i_addr, di_depth, ip->i_depth, + *ref_count, (*ref_count) << (ip->i_depth - di_depth)); + (*ref_count) <<= (ip->i_depth - di_depth); } brelse(lbh); if (error < 0) @@ -670,15 +643,12 @@ bad_leaf: return fix;
} - if (di_depth < ip->i_di.di_depth) { - log_debug(_("Depth of directory %lld (0x%llx) changed from " + if (di_depth < ip->i_depth) { + log_debug(_("Depth of directory %"PRIu64" (0x%"PRIx64") changed from " "%d to %d. Adjusting ref_count from %d to %d\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - di_depth, ip->i_di.di_depth, - *ref_count, - (*ref_count) << (ip->i_di.di_depth - di_depth)); - (*ref_count) <<= (ip->i_di.di_depth - di_depth); + ip->i_addr, ip->i_addr, di_depth, ip->i_depth, + *ref_count, (*ref_count) << (ip->i_depth - di_depth)); + (*ref_count) <<= (ip->i_depth - di_depth); } return 1; } @@ -718,7 +688,7 @@ static void dir_leaf_reada(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize) int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass) { int error = 0; - unsigned hsize = (1 << ip->i_di.di_depth); + unsigned hsize = (1 << ip->i_depth); uint64_t leaf_no, leaf_next; uint64_t first_ok_leaf, orig_di_blocks; struct gfs2_buffer_head *lbh; @@ -734,9 +704,9 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass) return -1; } tbl_valid = 1; - orig_di_depth = ip->i_di.di_depth; - orig_di_height = ip->i_di.di_height; - orig_di_blocks = ip->i_di.di_blocks; + orig_di_depth = ip->i_depth; + orig_di_height = ip->i_height; + orig_di_blocks = ip->i_blocks;
/* Turn off system readahead */ posix_fadvise(sdp->device_fd, 0, 0, POSIX_FADV_RANDOM); @@ -780,10 +750,8 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass) } } if (first_ok_leaf == -1) { /* no valid leaf found */ - log_err( _("Directory #%llu (0x%llx) has no valid leaf " - "blocks\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Directory #%"PRIu64" (0x%"PRIx64") has no valid leaf blocks\n"), + ip->i_addr, ip->i_addr); free(tbl); posix_fadvise(sdp->device_fd, 0, 0, POSIX_FADV_NORMAL); return 1; @@ -798,17 +766,16 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass)
if (!tbl_valid) { free(tbl); - log_debug(_("Re-reading 0x%llx hash table.\n"), - (unsigned long long)ip->i_di.di_num.no_addr); + log_debug(_("Re-reading 0x%"PRIx64" hash table.\n"), ip->i_addr); tbl = get_dir_hash(ip); if (tbl == NULL) { perror("get_dir_hash"); return -1; } tbl_valid = 1; - orig_di_depth = ip->i_di.di_depth; - orig_di_height = ip->i_di.di_height; - orig_di_blocks = ip->i_di.di_blocks; + orig_di_depth = ip->i_depth; + orig_di_height = ip->i_height; + orig_di_blocks = ip->i_blocks; } leaf_no = be64_to_cpu(tbl[lindex]);
@@ -853,27 +820,21 @@ int check_leaf_blks(struct gfs2_inode *ip, struct metawalk_fxns *pass) log_debug( _("Leaf chain #%d (0x%llx) detected.\n"), chained_leaf, (unsigned long long)leaf_no); } while (1); /* while we have chained leaf blocks */ - if (orig_di_depth != ip->i_di.di_depth) { - log_debug(_("Depth of 0x%llx changed from %d to %d\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - orig_di_depth, ip->i_di.di_depth); + if (orig_di_depth != ip->i_depth) { + log_debug(_("Depth of 0x%"PRIx64" changed from %d to %d\n"), + ip->i_addr, orig_di_depth, ip->i_depth); tbl_valid = 0; - lindex <<= (ip->i_di.di_depth - orig_di_depth); - hsize = (1 << ip->i_di.di_depth); + lindex <<= (ip->i_depth - orig_di_depth); + hsize = (1 << ip->i_depth); } - if (orig_di_height != ip->i_di.di_height) { - log_debug(_("Height of 0x%llx changed from %d to " - "%d\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - orig_di_height, ip->i_di.di_height); + if (orig_di_height != ip->i_height) { + log_debug(_("Height of 0x%"PRIx64" changed from %d to %d\n"), + ip->i_addr, orig_di_height, ip->i_height); tbl_valid = 0; } - if (orig_di_blocks != ip->i_di.di_blocks) { - log_debug(_("Block count of 0x%llx changed from %llu " - "to %llu\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)orig_di_blocks, - (unsigned long long)ip->i_di.di_blocks); + if (orig_di_blocks != ip->i_blocks) { + log_debug(_("Block count of 0x%"PRIx64" changed from %"PRIu64" to %"PRIu64"\n"), + ip->i_addr, orig_di_blocks, ip->i_blocks); tbl_valid = 0; } lindex += ref_count; @@ -967,12 +928,9 @@ static int check_leaf_eattr(struct gfs2_inode *ip, uint64_t block, if (pass->check_eattr_leaf) { int error = 0;
- log_debug( _("Checking EA leaf block #%llu (0x%llx) for " - "inode #%llu (0x%llx).\n"), - (unsigned long long)block, - (unsigned long long)block, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_debug(_("Checking EA leaf block #%"PRIu64" (0x%"PRIx64") for " + "inode #%"PRIu64" (0x%"PRIx64").\n"), + block, block, ip->i_addr, ip->i_addr);
error = pass->check_eattr_leaf(ip, block, parent, &bh, pass->private); @@ -1011,7 +969,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect, uint64_t block; struct gfs2_sbd *sdp = ip->i_sbd; int first_ea_is_bad = 0; - uint64_t di_eattr_save = ip->i_di.di_eattr; + uint64_t di_eattr_save = ip->i_eattr; uint64_t offset = ip->i_sbd->gfs1 ? sizeof(struct gfs_indirect) : sizeof(struct gfs2_meta_header); int leaf_pointers = 0, leaf_pointer_errors = 0;
@@ -1064,7 +1022,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect, check_leaf_eattr to delete all eattrs after the bad one. So we want: GGGG when we finish. To do that, we set di_eattr to 0 temporarily. */ - ip->i_di.di_eattr = 0; + ip->i_eattr = 0; bmodified(ip->i_bh); } ea_leaf_ptr++; @@ -1072,7 +1030,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t indirect, /* If we temporarily nuked the ea block to prevent checking past a corrupt ea leaf, we need to restore the saved di_eattr block. */ if (di_eattr_save != 0) - ip->i_di.di_eattr = di_eattr_save; + ip->i_eattr = di_eattr_save; if (pass->finish_eattr_indir) { if (!first_ea_is_bad) { pass->finish_eattr_indir(ip, leaf_pointers, @@ -1100,24 +1058,20 @@ int check_inode_eattr(struct gfs2_inode *ip, struct metawalk_fxns *pass) int error = 0; struct gfs2_buffer_head *indirect_buf = NULL;
- if (!ip->i_di.di_eattr) + if (!ip->i_eattr) return 0;
- if (ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT){ + if (ip->i_flags & GFS2_DIF_EA_INDIRECT){ if (!pass->check_eattr_indir) return 0;
- log_debug( _("Checking EA indirect block #%llu (0x%llx) for " - "inode #%llu (0x%llx)..\n"), - (unsigned long long)ip->i_di.di_eattr, - (unsigned long long)ip->i_di.di_eattr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); - error = pass->check_eattr_indir(ip, ip->i_di.di_eattr, - ip->i_di.di_num.no_addr, + log_debug(_("Checking EA indirect block #%"PRIu64" (0x%"PRIx64") for " + "inode #%"PRIu64" (0x%"PRIx64")..\n"), + ip->i_eattr, ip->i_eattr, ip->i_addr, ip->i_addr); + error = pass->check_eattr_indir(ip, ip->i_eattr, ip->i_addr, &indirect_buf, pass->private); if (!error) { - error = check_indirect_eattr(ip, ip->i_di.di_eattr, + error = check_indirect_eattr(ip, ip->i_eattr, indirect_buf, pass); if (error) stack; @@ -1126,8 +1080,7 @@ int check_inode_eattr(struct gfs2_inode *ip, struct metawalk_fxns *pass) brelse(indirect_buf); return error; } - error = check_leaf_eattr(ip, ip->i_di.di_eattr, - ip->i_di.di_num.no_addr, pass); + error = check_leaf_eattr(ip, ip->i_eattr, ip->i_addr, pass); if (error) stack;
@@ -1139,7 +1092,7 @@ int check_inode_eattr(struct gfs2_inode *ip, struct metawalk_fxns *pass) */ static void free_metalist(struct gfs2_inode *ip, osi_list_t *mlp) { - unsigned int height = ip->i_di.di_height; + unsigned int height = ip->i_height; unsigned int i; struct gfs2_buffer_head *nbh;
@@ -1165,7 +1118,7 @@ static void file_ra(struct gfs2_inode *ip, struct gfs2_buffer_head *bh, uint64_t *p, sblock = 0, block; int extlen = 0;
- if (h + 2 == ip->i_di.di_height) { + if (h + 2 == ip->i_height) { p = (uint64_t *)(bh->b_data + head_size); if (*p && *(p + 1)) { sblock = be64_to_cpu(*p); @@ -1272,7 +1225,7 @@ static int do_check_metalist(struct iptr iptr, int height, struct gfs2_buffer_he static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp, struct metawalk_fxns *pass) { - uint32_t height = ip->i_di.di_height; + uint32_t height = ip->i_height; struct gfs2_buffer_head *metabh = ip->i_bh; osi_list_t *prev_list, *cur_list, *tmp; struct iptr iptr = { .ipt_ip = ip, 0}; @@ -1288,7 +1241,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp, because it checks everything through the hash table using "depth" field calculations. However, we still have to check the indirect blocks, even if the height == 1. */ - if (is_dir(&ip->i_di, ip->i_sbd->gfs1)) + if (is_dir(ip, ip->i_sbd->gfs1)) height++;
/* if (<there are no indirect blocks to check>) */ @@ -1296,8 +1249,8 @@ static int build_and_check_metalist(struct gfs2_inode *ip, osi_list_t *mlp, return META_IS_GOOD; for (h = 1; h < height; h++) { if (h > 1) { - if (is_dir(&ip->i_di, ip->i_sbd->gfs1) && - h == ip->i_di.di_height + 1) + if (is_dir(ip, ip->i_sbd->gfs1) && + h == ip->i_height + 1) iblk_type = GFS2_METATYPE_JD; else iblk_type = GFS2_METATYPE_IN; @@ -1454,9 +1407,8 @@ static int metawalk_check_data(struct gfs2_inode *ip, struct metawalk_fxns *pass uint64_t metablock = bh->b_blocknr;
/* If there isn't much pointer corruption check the pointers */ - log_debug("Processing data blocks for inode 0x%llx, metadata block 0x%llx.\n", - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)metablock); + log_debug("Processing data blocks for inode 0x%"PRIx64", metadata block 0x%"PRIx64".\n", + ip->i_addr, metablock); for (ptr = ptr_start ; ptr < ptr_end && !fsck_abort; ptr++) { if (!*ptr) continue; @@ -1556,7 +1508,7 @@ static unsigned int should_check(struct gfs2_buffer_head *bh, unsigned int heigh */ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass) { - unsigned int height = ip->i_di.di_height; + unsigned int height = ip->i_height; osi_list_t *metalist = alloca((height + 1) * sizeof(*metalist)); osi_list_t *list, *tmp; struct gfs2_buffer_head *bh; @@ -1567,7 +1519,7 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass) struct error_block error_blk = {0, 0, 0}; int hit_error_blk = 0;
- if (!height && !is_dir(&ip->i_di, ip->i_sbd->gfs1)) + if (!height && !is_dir(ip, ip->i_sbd->gfs1)) return 0;
/* metalist has one extra element for directories (see build_and_check_metalist). */ @@ -1585,8 +1537,8 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass) /* For directories, we've already checked the "data" blocks which * comprise the directory hash table, so we perform the directory * checks and exit. */ - if (is_dir(&ip->i_di, ip->i_sbd->gfs1)) { - if (!(ip->i_di.di_flags & GFS2_DIF_EXHASH)) + if (is_dir(ip, ip->i_sbd->gfs1)) { + if (!(ip->i_flags & GFS2_DIF_EXHASH)) goto out; /* check validity of leaf blocks and leaf chains */ error = check_leaf_blks(ip, pass); @@ -1597,7 +1549,7 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass)
/* check data blocks */ list = &metalist[height - 1]; - if (ip->i_di.di_blocks > COMFORTABLE_BLKS) + if (ip->i_blocks > COMFORTABLE_BLKS) last_reported_fblock = -10000000;
for (tmp = list->next; !error && tmp != list; tmp = tmp->next) { @@ -1612,30 +1564,24 @@ int check_metatree(struct gfs2_inode *ip, struct metawalk_fxns *pass) if (pass->check_data) error = metawalk_check_data(ip, pass, bh, height, &blks_checked, &error_blk); - if (pass->big_file_msg && ip->i_di.di_blocks > COMFORTABLE_BLKS) + if (pass->big_file_msg && ip->i_blocks > COMFORTABLE_BLKS) pass->big_file_msg(ip, blks_checked); } - if (pass->big_file_msg && ip->i_di.di_blocks > COMFORTABLE_BLKS) { - log_notice( _("\rLarge file at %lld (0x%llx) - 100 percent " + if (pass->big_file_msg && ip->i_blocks > COMFORTABLE_BLKS) { + log_notice( _("\rLarge file at %"PRIu64" (0x%"PRIx64") - 100 percent " "complete. " "\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + ip->i_addr, ip->i_addr); fflush(stdout); } undo_metalist: if (!error) goto out; - log_err( _("Error: inode %llu (0x%llx) had unrecoverable errors at " - "metadata block %lld (0x%llx), offset %d (0x%x), block " - "%lld (0x%llx).\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)error_blk.metablk, - (unsigned long long)error_blk.metablk, - error_blk.metaoff, error_blk.metaoff, - (unsigned long long)error_blk.errblk, - (unsigned long long)error_blk.errblk); + log_err(_("Error: inode %"PRIu64" (0x%"PRIx64") had unrecoverable errors at " + "metadata block %"PRIu64" (0x%"PRIx64"), offset %d (0x%x), block " + "%"PRIu64" (0x%"PRIx64").\n"), + ip->i_addr, ip->i_addr, error_blk.metablk, error_blk.metablk, + error_blk.metaoff, error_blk.metaoff, error_blk.errblk, error_blk.errblk); if (!query( _("Remove the invalid inode? (y/n) "))) { free_metalist(ip, metalist); log_err(_("Invalid inode not deleted.\n")); @@ -1668,10 +1614,9 @@ undo_metalist: hit_error_blk = 1; log_err("Reached the error " "block undoing work " - "for inode %lld " - "(0x%llx).\n", - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + "for inode %"PRIu64" " + "(0x%"PRIx64").\n", + ip->i_addr, ip->i_addr); rc = 0; } } @@ -1688,8 +1633,7 @@ undo_metalist: to undo. */ delete_all_dups(ip); /* Set the dinode as "bad" so it gets deleted */ - fsck_bitmap_set(ip, ip->i_di.di_num.no_addr, "corrupt", - GFS2_BLKST_FREE); + fsck_bitmap_set(ip, ip->i_addr, "corrupt", GFS2_BLKST_FREE); log_err(_("The corrupt inode was invalidated.\n")); out: free_metalist(ip, metalist); @@ -1716,7 +1660,7 @@ int check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip, struct metawalk_fxns { int error = 0;
- if (ip->i_di.di_flags & GFS2_DIF_EXHASH) + if (ip->i_flags & GFS2_DIF_EXHASH) error = check_leaf_blks(ip, pass); else error = check_linear_dir(ip, ip->i_bh, pass); diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c index 0cd9b274..3454fd56 100644 --- a/gfs2/fsck/pass1.c +++ b/gfs2/fsck/pass1.c @@ -134,12 +134,8 @@ static int pass1_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no, char *padbuf; int pad_size, i;
- log_err( _("Directory Inode %llu (0x%llx) points to leaf %llu" - " (0x%llx) %s.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)*leaf_no, - (unsigned long long)*leaf_no, msg); + log_err(_("Directory Inode %"PRIu64" (0x%"PRIx64") points to leaf %"PRIu64" (0x%"PRIx64") %s.\n"), + ip->i_addr, ip->i_addr, *leaf_no, *leaf_no, msg); if (!query( _("Attempt to patch around it? (y/n) "))) { log_err( _("Bad leaf left in place.\n")); goto out; @@ -152,19 +148,16 @@ static int pass1_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no, cpyptr++; } pad_size = ref_count * sizeof(uint64_t); - log_err(_("Writing zeros to the hash table of directory %lld " - "(0x%llx) at index: 0x%x for 0x%x pointers.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, lindex, - ref_count); + log_err(_("Writing zeros to the hash table of directory %"PRIu64 + " (0x%"PRIx64") at index: 0x%x for 0x%x pointers.\n"), + ip->i_addr, ip->i_addr, lindex, ref_count); if (ip->i_sbd->gfs1) gfs1_writei(ip, padbuf, lindex * sizeof(uint64_t), pad_size); else gfs2_writei(ip, padbuf, lindex * sizeof(uint64_t), pad_size); free(padbuf); - log_err( _("Directory Inode %llu (0x%llx) patched.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Directory Inode %"PRIu64" (0x%"PRIx64") patched.\n"), + ip->i_addr, ip->i_addr);
out: *leaf_no = 0; @@ -207,12 +200,10 @@ static int resuscitate_metalist(struct iptr iptr, struct gfs2_buffer_head **bh, *was_duplicate = 0; *bh = NULL; if (!valid_block_ip(ip, block)){ /* blk outside of FS */ - fsck_blockmap_set(ip, ip->i_di.di_num.no_addr, - _("itself"), GFS2_BLKST_UNLINKED); - log_err( _("Bad indirect block pointer (invalid or out of " - "range) found in system inode %lld (0x%llx).\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + fsck_blockmap_set(ip, ip->i_addr, _("itself"), GFS2_BLKST_UNLINKED); + log_err(_("Bad indirect block pointer (invalid or out of " + "range) found in system inode %"PRIu64" (0x%"PRIx64").\n"), + ip->i_addr, ip->i_addr); *is_valid = 0; return META_IS_GOOD; } @@ -255,11 +246,9 @@ static int resuscitate_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, else strncpy(tmp_name, filename, sizeof(tmp_name) - 1); if (!valid_block_ip(ip, block)) { - log_err( _("Block # referenced by system directory entry %s " - "in inode %lld (0x%llx) is invalid or out of range;" - " ignored.\n"), - tmp_name, (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Block # referenced by system directory entry %s in inode " + "%"PRIu64" (0x%"PRIx64") is invalid or out of range; ignored.\n"), + tmp_name, ip->i_addr, ip->i_addr); return 0; } /* If this is a system dinode, we'll handle it later in @@ -296,14 +285,11 @@ static int p1check_leaf(struct gfs2_inode *ip, uint64_t block, void *private) bc->indir_count++; q = block_type(bl, block); if (q != GFS2_BLKST_FREE) { - log_err( _("Found duplicate block #%llu (0x%llx) referenced " - "as a directory leaf in dinode " - "%llu (0x%llx) - was marked %d (%s)\n"), - (unsigned long long)block, - (unsigned long long)block, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, q, - block_type_string(q)); + log_err(_("Found duplicate block #%"PRIu64" (0x%"PRIx64") referenced " + "as a directory leaf in dinode " + "%"PRIu64" (0x%"PRIx64") - was marked %d (%s)\n"), + block, block, ip->i_addr, ip->i_addr, q, + block_type_string(q)); add_duplicate_ref(ip, block, REF_AS_META, 0, INODE_VALID); if (q == (ip->i_sbd->gfs1 ? GFS2_BLKST_DINODE : GFS2_BLKST_USED)) @@ -337,16 +323,15 @@ static int pass1_check_metalist(struct iptr iptr, struct gfs2_buffer_head **bh, "unrecoverable" errors. The inode itself should be set "free" and removed from the inodetree by undo_check_metalist. */ - fsck_blockmap_set(ip, ip->i_di.di_num.no_addr, + fsck_blockmap_set(ip, ip->i_addr, _("bad block referencing"), GFS2_BLKST_UNLINKED); - log_debug( _("Bad indirect block (invalid/out of range) " - "found in inode %lld (0x%llx).\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_debug(_("Bad indirect block (invalid/out of range) " + "found in inode %"PRIu64" (0x%"PRIx64").\n"), + ip->i_addr, ip->i_addr);
return META_SKIP_FURTHER; } - if (is_dir(&ip->i_di, ip->i_sbd->gfs1) && h == ip->i_di.di_height) { + if (is_dir(ip, ip->i_sbd->gfs1) && h == ip->i_height) { iblk_type = GFS2_METATYPE_JD; blktypedesc = _("a directory hash table block"); } else { @@ -355,13 +340,10 @@ static int pass1_check_metalist(struct iptr iptr, struct gfs2_buffer_head **bh, } q = block_type(bl, block); if (q != GFS2_BLKST_FREE) { - log_err( _("Found duplicate block #%llu (0x%llx) referenced " - "as metadata in indirect block for dinode " - "%llu (0x%llx) - was marked %d (%s)\n"), - (unsigned long long)block, - (unsigned long long)block, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, q, + log_err(_("Found duplicate block #%"PRIu64" (0x%"PRIx64") referenced " + "as metadata in indirect block for dinode " + "%"PRIu64" (0x%"PRIx64") - was marked %d (%s)\n"), + block, block, ip->i_addr, ip->i_addr, q, block_type_string(q)); *was_duplicate = 1; } @@ -370,13 +352,10 @@ static int pass1_check_metalist(struct iptr iptr, struct gfs2_buffer_head **bh, *is_valid = (gfs2_check_meta(nbh->b_data, iblk_type) == 0);
if (!(*is_valid)) { - log_err( _("Inode %lld (0x%llx) has a bad indirect block " - "pointer %lld (0x%llx) (points to something " - "that is not %s).\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)block, - (unsigned long long)block, blktypedesc); + log_err(_("Inode %"PRIu64" (0x%"PRIx64") has a bad indirect block " + "pointer %"PRIu64" (0x%"PRIx64") (points to something " + "that is not %s).\n"), + ip->i_addr, ip->i_addr, block, block, blktypedesc); if (query(_("Zero the indirect block pointer? (y/n) "))){ *iptr_ptr(iptr) = 0; bmodified(iptr.ipt_bh); @@ -423,8 +402,7 @@ static int undo_reference(struct gfs2_inode *ip, uint64_t block, int meta, struct rgrp_tree *rgd;
if (!valid_block_ip(ip, block)) { /* blk outside of FS */ - fsck_blockmap_set(ip, ip->i_di.di_num.no_addr, - _("bad block referencing"), GFS2_BLKST_FREE); + fsck_blockmap_set(ip, ip->i_addr, _("bad block referencing"), GFS2_BLKST_FREE); return 1; }
@@ -509,12 +487,9 @@ static int blockmap_set_as_data(struct gfs2_inode *ip, uint64_t block) if (be64_to_cpu(di->di_num.no_addr) != block) goto out;
- log_err(_("Inode %lld (0x%llx) has a reference to block %lld (0x%llx) " - "as a data block, but it appears to be a dinode we " - "haven't checked yet.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)block, (unsigned long long)block); + log_err(_("Inode %"PRIu64" (0x%"PRIx64") has a reference to block %"PRIu64" (0x%"PRIx64") " + "as a data block, but it appears to be a dinode we haven't checked yet.\n"), + ip->i_addr, ip->i_addr, block, block); error = -1; out: if (!error) @@ -531,23 +506,18 @@ static int pass1_check_data(struct gfs2_inode *ip, uint64_t metablock, struct block_count *bc = (struct block_count *) private;
if (!valid_block_ip(ip, block)) { - log_err( _("inode %lld (0x%llx) has a bad data block pointer " - "%lld (0x%llx) (invalid or out of range) "), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)block, (unsigned long long)block); - if (metablock == ip->i_di.di_num.no_addr) + log_err(_("inode %"PRIu64" (0x%"PRIx64") has a bad data block pointer " + "%"PRIu64" (0x%"PRIx64") (invalid or out of range) "), + ip->i_addr, ip->i_addr, block, block); + if (metablock == ip->i_addr) log_err("\n"); else - log_err(_("from metadata block %llu (0x%llx)\n"), - (unsigned long long)metablock, - (unsigned long long)metablock); + log_err(_("from metadata block %"PRIu64" (0x%"PRIx64")\n"), + metablock, metablock); /* Mark the owner of this block with the bad_block * designator so we know to check it for out of range * blocks later */ - fsck_blockmap_set(ip, ip->i_di.di_num.no_addr, - _("bad (out of range) data"), - GFS2_BLKST_UNLINKED); + fsck_blockmap_set(ip, ip->i_addr, _("bad (out of range) data"), GFS2_BLKST_UNLINKED); return -1; } bc->data_count++; /* keep the count sane anyway */ @@ -556,14 +526,11 @@ static int pass1_check_data(struct gfs2_inode *ip, uint64_t metablock, struct gfs2_buffer_head *bh; struct gfs2_meta_header mh;
- log_err( _("Found duplicate %s block %llu (0x%llx) " - "referenced as data by dinode %llu (0x%llx) "), - block_type_string(q), - (unsigned long long)block, - (unsigned long long)block, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); - if (metablock == ip->i_di.di_num.no_addr) + log_err(_("Found duplicate %s block %"PRIu64" (0x%"PRIx64") " + "referenced as data by dinode %"PRIu64" (0x%"PRIx64") "), + block_type_string(q), + block, block, ip->i_addr, ip->i_addr); + if (metablock == ip->i_addr) log_err("\n"); else log_err(_("from metadata block %llu (0x%llx)\n"), @@ -625,7 +592,7 @@ static int pass1_check_data(struct gfs2_inode *ip, uint64_t metablock, gfs2_special_set(&gfs1_rindex_blks, block); fsck_blockmap_set(ip, block, "rgrp", GFS2_BLKST_DINODE); /*gfs2_meta_rgrp);*/ - } else if (ip->i_sbd->gfs1 && ip->i_di.di_flags & GFS2_DIF_JDATA) { + } else if (ip->i_sbd->gfs1 && ip->i_flags & GFS2_DIF_JDATA) { log_info(_("Block %lld (0x%llx) is a GFS1 journaled data " "block\n"), (unsigned long long)block, (unsigned long long)block); @@ -638,17 +605,16 @@ static int pass1_check_data(struct gfs2_inode *ip, uint64_t metablock, static int ask_remove_inode_eattr(struct gfs2_inode *ip, struct block_count *bc) { - if (ip->i_di.di_eattr == 0) + if (ip->i_eattr == 0) return 0; /* eattr was removed prior to this call */ - log_err( _("Inode %lld (0x%llx) has unrecoverable Extended Attribute " - "errors.\n"), (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Inode %"PRIu64" (0x%"PRIx64") has unrecoverable Extended Attribute errors.\n"), + ip->i_addr, ip->i_addr); if (query( _("Clear all Extended Attributes from the inode? (y/n) "))){ - undo_reference(ip, ip->i_di.di_eattr, 0, bc); - ip->i_di.di_eattr = 0; + undo_reference(ip, ip->i_eattr, 0, bc); + ip->i_eattr = 0; bc->ea_count = 0; - ip->i_di.di_blocks = 1 + bc->indir_count + bc->data_count; - ip->i_di.di_flags &= ~GFS2_DIF_EA_INDIRECT; + ip->i_blocks = 1 + bc->indir_count + bc->data_count; + ip->i_flags &= ~GFS2_DIF_EA_INDIRECT; bmodified(ip->i_bh); log_err( _("Extended attributes were removed.\n")); } else { @@ -698,11 +664,8 @@ static int undo_eattr_indir_or_leaf(struct gfs2_inode *ip, uint64_t block, static void complain_eas(struct gfs2_inode *ip, uint64_t block, const char *emsg) { - log_err(_("Inode #%llu (0x%llx): %s"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, emsg); - log_err(_(" at block #%lld (0x%llx).\n"), - (unsigned long long)block, (unsigned long long)block); + log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): %s"), ip->i_addr, ip->i_addr, emsg); + log_err(_(" at block #%"PRIu64" (0x%"PRIx64").\n"), block, block); }
static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect, @@ -769,25 +732,17 @@ static int finish_eattr_indir(struct gfs2_inode *ip, int leaf_pointers,
if (leaf_pointer_errors == leaf_pointers) /* All eas were bad */ return ask_remove_inode_eattr(ip, bc); - log_debug( _("Marking inode #%llu (0x%llx) with extended " - "attribute block\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_debug(_("Marking inode #%"PRIu64" (0x%"PRIx64") with extended attribute block\n"), + ip->i_addr, ip->i_addr); if (!leaf_pointer_errors) return 0; - log_err( _("Inode %lld (0x%llx) has recoverable indirect " - "Extended Attribute errors.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Inode %"PRIu64" (0x%"PRIx64") has recoverable indirect extended attribute errors.\n"), + ip->i_addr, ip->i_addr); if (query( _("Okay to fix the block count for the inode? (y/n) "))) { - ip->i_di.di_blocks = 1 + bc->indir_count + - bc->data_count + bc->ea_count; + ip->i_blocks = 1 + bc->indir_count + bc->data_count + bc->ea_count; bmodified(ip->i_bh); - log_err(_("Block count fixed: 1+%lld+%lld+%lld = %lld.\n"), - (unsigned long long)bc->indir_count, - (unsigned long long)bc->data_count, - (unsigned long long)bc->ea_count, - (unsigned long long)ip->i_di.di_blocks); + log_err(_("Block count fixed: 1+%"PRIu64"+%"PRIu64"+%"PRIu64" = %"PRIu64".\n"), + bc->indir_count, bc->data_count, bc->ea_count, ip->i_blocks); return 1; } log_err( _("Block count not fixed.\n")); @@ -875,18 +830,12 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, int i, int error = 0;
if (!valid_block_ip(ip, el_blk)) { - log_err( _("Inode #%llu (0x%llx): Extended Attribute block " - "%llu (0x%llx) has an extended leaf block #%llu " - "(0x%llx) that is invalid or out of range.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_eattr, - (unsigned long long)ip->i_di.di_eattr, - (unsigned long long)el_blk, - (unsigned long long)el_blk); - fsck_blockmap_set(ip, ip->i_di.di_eattr, - _("bad (out of range) Extended Attribute "), - GFS2_BLKST_UNLINKED); + log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): extended attribute block " + "%"PRIu64" (0x%"PRIx64") has an extended leaf block #%"PRIu64" " + "(0x%"PRIx64") that is invalid or out of range.\n"), + ip->i_addr, ip->i_addr, ip->i_eattr, ip->i_eattr, el_blk, el_blk); + fsck_blockmap_set(ip, ip->i_eattr, _("bad (out of range) Extended Attribute "), + GFS2_BLKST_UNLINKED); error = 1; } else { error = check_ealeaf_block(ip, el_blk, GFS2_METATYPE_ED, &bh, @@ -906,7 +855,7 @@ static int check_extended_leaf_eattr(struct gfs2_inode *ip, int i, bmodified(leaf_bh); /* Endianness doesn't matter in this case because it's a single byte. */ - fsck_blockmap_set(ip, ip->i_di.di_eattr, + fsck_blockmap_set(ip, ip->i_eattr, _("extended attribute"), sdp->gfs1 ? GFS2_BLKST_DINODE : GFS2_BLKST_USED); @@ -925,15 +874,12 @@ static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block, void *private) { if (!valid_block_ip(ip, block)) { - log_warn( _("Inode #%llu (0x%llx): Extended Attribute leaf " - "block #%llu (0x%llx) is invalid or out of " - "range.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)block, (unsigned long long)block); - fsck_blockmap_set(ip, ip->i_di.di_eattr, - _("bad (out of range) Extended " - "Attribute leaf"), GFS2_BLKST_UNLINKED); + log_warn(_("Inode #%"PRIu64" (0x%"PRIx64"): extended attribute leaf " + "block #%"PRIu64" (0x%"PRIx64") is invalid or out of " + "range.\n"), + ip->i_addr, ip->i_addr, block, block); + fsck_blockmap_set(ip, ip->i_eattr, _("bad (out of range) extended attribute leaf"), + GFS2_BLKST_UNLINKED); return 1; } return check_ealeaf_block(ip, block, GFS2_METATYPE_EA, bh, private); @@ -1087,13 +1033,10 @@ static int mark_block_invalid(struct gfs2_inode *ip, uint64_t block, if (was_duplicate) *was_duplicate = 1; add_duplicate_ref(ip, block, reftype, 0, INODE_INVALID); - log_info( _("%s block %lld (0x%llx), part of inode " - "%lld (0x%llx), was previously referenced so " - "the invalid reference is ignored.\n"), - btype, (unsigned long long)block, - (unsigned long long)block, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_info(_("%s block %"PRIu64" (0x%"PRIx64"), part of inode " + "%"PRIu64" (0x%"PRIx64"), was previously referenced so " + "the invalid reference is ignored.\n"), + btype, block, block, ip->i_addr, ip->i_addr); return META_IS_GOOD; } fsck_blockmap_set(ip, block, btype, GFS2_BLKST_UNLINKED); @@ -1181,11 +1124,9 @@ static int rangecheck_block(struct gfs2_inode *ip, uint64_t block,
if (!valid_block_ip(ip, block)) { (*bad_pointers)++; - log_info( _("Bad %s block pointer (invalid or out of range " - "#%ld) found in inode %lld (0x%llx).\n"), - btypes[btype], *bad_pointers, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_info(_("Bad %s block pointer (invalid or out of range " + "#%ld) found in inode %"PRIu64" (0x%"PRIx64").\n"), + btypes[btype], *bad_pointers, ip->i_addr, ip->i_addr); if ((*bad_pointers) <= BAD_POINTER_TOLERANCE) return META_IS_GOOD; else @@ -1195,19 +1136,15 @@ static int rangecheck_block(struct gfs2_inode *ip, uint64_t block, q = block_type(bl, block); if (q != GFS2_BLKST_FREE) { (*bad_pointers)++; - log_info( _("Duplicated %s block pointer (violation %ld, block" - " %lld (0x%llx)) found in inode %lld (0x%llx).\n"), - btypes[btype], *bad_pointers, - (unsigned long long)block, (unsigned long long)block, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_info(_("Duplicated %s block pointer (violation %ld, block %"PRIu64 + " (0x%"PRIx64")) found in inode %"PRIu64" (0x%"PRIx64").\n"), + btypes[btype], *bad_pointers, block, block, ip->i_addr, ip->i_addr); if ((*bad_pointers) <= BAD_POINTER_TOLERANCE) return META_IS_GOOD; else { - log_debug(_("Inode 0x%llx bad pointer tolerance " - "exceeded: block 0x%llx.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)block); + log_debug(_("Inode 0x%"PRIx64" bad pointer tolerance " + "exceeded: block 0x%"PRIx64".\n"), + ip->i_addr, block); return META_ERROR; /* Exits check_metatree quicker */ } } @@ -1277,13 +1214,14 @@ struct metawalk_fxns eattr_undo_fxns = { static int set_ip_blockmap(struct gfs2_inode *ip) { uint64_t block = ip->i_bh->b_blocknr; + struct gfs2_inum no; uint32_t mode; const char *ty;
if (ip->i_sbd->gfs1) mode = gfs_to_gfs2_mode(ip); else - mode = ip->i_di.di_mode & S_IFMT; + mode = ip->i_mode & S_IFMT;
switch (mode) { case S_IFDIR: @@ -1310,8 +1248,10 @@ static int set_ip_blockmap(struct gfs2_inode *ip) default: return -EINVAL; } + no.no_addr = ip->i_addr; + no.no_formal_ino = ip->i_formal_ino; if (fsck_blockmap_set(ip, block, ty, GFS2_BLKST_DINODE) || - (mode == S_IFDIR && !dirtree_insert(ip->i_di.di_num))) { + (mode == S_IFDIR && !dirtree_insert(no))) { stack; return -EPERM; } @@ -1409,8 +1349,7 @@ static int pass1_check_metatree(struct gfs2_inode *ip,
error = check_metatree(ip, pass); if (error) - gfs2_blockmap_set(bl, ip->i_di.di_num.no_addr, - GFS2_BLKST_FREE); + gfs2_blockmap_set(bl, ip->i_addr, GFS2_BLKST_FREE); return error; }
@@ -1436,11 +1375,9 @@ static void reprocess_inode(struct gfs2_inode *ip, const char *desc) int error;
alloc_fxns.private = (void *)desc; - log_info( _("%s inode %llu (0x%llx) had blocks added; reprocessing " - "its metadata tree at height=%d.\n"), desc, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - ip->i_di.di_height); + log_info(_("%s inode %"PRIu64" (0x%"PRIx64") had blocks added; reprocessing " + "its metadata tree at height=%d.\n"), desc, + ip->i_addr, ip->i_addr, ip->i_height); error = pass1_check_metatree(ip, &alloc_fxns); if (error) log_err( _("Error %d reprocessing the %s metadata tree.\n"), @@ -1466,13 +1403,9 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip) rangecheck_fxns.private = &bad_pointers; error = pass1_check_metatree(ip, &rangecheck_fxns); if (bad_pointers > BAD_POINTER_TOLERANCE) { - log_err( _("Error: inode %llu (0x%llx) has more than " - "%d bad pointers.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - BAD_POINTER_TOLERANCE); - fsck_blockmap_set(ip, ip->i_di.di_num.no_addr, - _("badly corrupt"), GFS2_BLKST_FREE); + log_err(_("Error: inode %"PRIu64" (0x%"PRIx64") has more than %d bad pointers.\n"), + ip->i_addr, ip->i_addr, BAD_POINTER_TOLERANCE); + fsck_blockmap_set(ip, ip->i_addr, _("badly corrupt"), GFS2_BLKST_FREE); return 0; }
@@ -1484,8 +1417,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip) processed its metadata with pass1_fxns, none of its metadata will be flagged as metadata or data blocks yet. Therefore, we don't need to invalidate anything. */ - fsck_blockmap_set(ip, ip->i_di.di_num.no_addr, - _("invalid mode"), GFS2_BLKST_FREE); + fsck_blockmap_set(ip, ip->i_addr, _("invalid mode"), GFS2_BLKST_FREE); return 0; } else if (error) goto bad_dinode; @@ -1494,7 +1426,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip) goto bad_dinode;
if (lf_dip) - lf_blks = lf_dip->i_di.di_blocks; + lf_blks = lf_dip->i_blocks;
pass1_fxns.private = &bc; error = pass1_check_metatree(ip, &pass1_fxns); @@ -1502,7 +1434,7 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip) /* Pass1 may have added some blocks to lost+found by virtue of leafs that were misplaced. If it did, we need to reprocess lost+found to correctly account for its blocks. */ - if (lf_dip && lf_dip->i_di.di_blocks != lf_blks) + if (lf_dip && lf_dip->i_blocks != lf_blks) reprocess_inode(lf_dip, "lost+found");
/* We there was an error, we return 0 because we want fsck to continue @@ -1521,9 +1453,8 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip) return 0; } log_err(_("Clearing the bad Extended Attributes in " - "inode %lld (0x%llx).\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + "inode %"PRIu64" (0x%"PRIx64").\n"), + ip->i_addr, ip->i_addr); eattr_undo_fxns.private = &bc; check_inode_eattr(ip, &eattr_undo_fxns); ask_remove_inode_eattr(ip, &bc); @@ -1531,33 +1462,22 @@ static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip) } }
- if (ip->i_di.di_blocks != - (1 + bc.indir_count + bc.data_count + bc.ea_count)) { - log_err( _("Inode #%llu (0x%llx): Ondisk block count (%llu" - ") does not match what fsck found (%llu)\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_blocks, - (unsigned long long)1 + bc.indir_count + - bc.data_count + bc.ea_count); - log_info( _("inode has: %lld, but fsck counts: Dinode:1 + " - "indir:%lld + data: %lld + ea: %lld\n"), - (unsigned long long)ip->i_di.di_blocks, - (unsigned long long)bc.indir_count, - (unsigned long long)bc.data_count, - (unsigned long long)bc.ea_count); + if (ip->i_blocks != (1 + bc.indir_count + bc.data_count + bc.ea_count)) { + log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): Ondisk block count (%"PRIu64 + ") does not match what fsck found (%"PRIu64")\n"), + ip->i_addr, ip->i_addr, ip->i_blocks, 1 + bc.indir_count + + bc.data_count + bc.ea_count); + log_info(_("inode has: %"PRIu64", but fsck counts: Dinode:1 + " + "indir:%"PRIu64" + data: %"PRIu64" + ea: %"PRIu64"\n"), + ip->i_blocks, bc.indir_count, bc.data_count, bc.ea_count); if (query( _("Fix ondisk block count? (y/n) "))) { - ip->i_di.di_blocks = 1 + bc.indir_count + bc.data_count + - bc.ea_count; + ip->i_blocks = 1 + bc.indir_count + bc.data_count + bc.ea_count; bmodified(ip->i_bh); - log_err( _("Block count for #%llu (0x%llx) fixed\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Block count for #%"PRIu64" (0x%"PRIx64") fixed\n"), + ip->i_addr, ip->i_addr); } else - log_err( _("Bad block count for #%llu (0x%llx" - ") not fixed\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Bad block count for #%"PRIu64" (0x%"PRIx64") not fixed\n"), + ip->i_addr, ip->i_addr); }
return 0; @@ -1568,27 +1488,22 @@ bad_dinode:
static void check_i_goal(struct gfs2_sbd *sdp, struct gfs2_inode *ip) { - if (sdp->gfs1 || ip->i_di.di_flags & GFS2_DIF_SYSTEM) + if (sdp->gfs1 || ip->i_flags & GFS2_DIF_SYSTEM) return;
- if (ip->i_di.di_goal_meta <= LGFS2_SB_ADDR(sdp) || - ip->i_di.di_goal_meta > sdp->fssize) { - log_err(_("Inode #%llu (0x%llx): Bad allocation goal block " - "found: %llu (0x%llx)\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_goal_meta, - (unsigned long long)ip->i_di.di_goal_meta); - if (query( _("Fix goal block in inode #%llu (0x%llx)? (y/n) "), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr)) { - ip->i_di.di_goal_meta = ip->i_di.di_num.no_addr; + if (ip->i_goal_meta <= LGFS2_SB_ADDR(sdp) || + ip->i_goal_meta > sdp->fssize) { + log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): Bad allocation goal block " + "found: %"PRIu64" (0x%"PRIx64")\n"), + ip->i_addr, ip->i_addr, ip->i_goal_meta, ip->i_goal_meta); + if (query(_("Fix goal block in inode #%"PRIu64" (0x%"PRIx64")? (y/n) "), + ip->i_addr, ip->i_addr)) { + ip->i_goal_meta = ip->i_addr; bmodified(ip->i_bh); } else - log_err(_("Allocation goal block in inode #%lld " - "(0x%llx) not fixed\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Allocation goal block in inode #%"PRIu64 + " (0x%"PRIx64") not fixed\n"), + ip->i_addr, ip->i_addr); } }
@@ -1605,33 +1520,25 @@ static int handle_di(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
ip = fsck_inode_get(sdp, rgd, bh);
- if (ip->i_di.di_num.no_addr != block) { - log_err( _("Inode #%llu (0x%llx): Bad inode address found: %llu " - "(0x%llx)\n"), (unsigned long long)block, - (unsigned long long)block, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); - if (query( _("Fix address in inode at block #%llu" - " (0x%llx)? (y/n) "), - (unsigned long long)block, (unsigned long long)block)) { - ip->i_di.di_num.no_addr = ip->i_di.di_num.no_formal_ino = block; + if (ip->i_addr != block) { + log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): Bad inode address found: %"PRIu64 + " (0x%"PRIx64")\n"), + block, block, ip->i_addr, ip->i_addr); + if (query(_("Fix address in inode at block #%"PRIu64" (0x%"PRIx64")? (y/n) "), + block, block)) { + ip->i_addr = ip->i_formal_ino = block; bmodified(ip->i_bh); } else - log_err( _("Address in inode at block #%llu" - " (0x%llx) not fixed\n"), - (unsigned long long)block, - (unsigned long long)block); - } - if (sdp->gfs1 && ip->i_di.di_num.no_formal_ino != block) { - log_err( _("Inode #%llu (0x%llx): GFS1 formal inode number " - "mismatch: was %llu (0x%llx)\n"), - (unsigned long long)block, (unsigned long long)block, - (unsigned long long)ip->i_di.di_num.no_formal_ino, - (unsigned long long)ip->i_di.di_num.no_formal_ino); - if (query( _("Fix formal inode number in inode #%llu" - " (0x%llx)? (y/n) "), (unsigned long long)block, - (unsigned long long)block)) { - ip->i_di.di_num.no_formal_ino = block; + log_err(_("Address in inode at block #%"PRIu64" (0x%"PRIx64" not fixed\n"), + block, block); + } + if (sdp->gfs1 && ip->i_formal_ino != block) { + log_err(_("Inode #%"PRIu64" (0x%"PRIx64"): GFS1 formal inode number " + "mismatch: was %"PRIu64" (0x%"PRIx64")\n"), + block, block, ip->i_formal_ino, ip->i_formal_ino); + if (query(_("Fix formal inode number in inode #%"PRIu64" (0x%"PRIx64")? (y/n) "), + block, block)) { + ip->i_formal_ino = block; bmodified(ip->i_bh); } else log_err( _("Inode number in inode at block #%lld " @@ -1663,7 +1570,7 @@ static int check_system_inode(struct gfs2_sbd *sdp, if (*sysinode) { /* Read in the system inode, look at its dentries, and start * reading through them */ - iblock = (*sysinode)->i_di.di_num.no_addr; + iblock = (*sysinode)->i_addr; log_info( _("System inode for '%s' is located at block %llu" " (0x%llx)\n"), filename, (unsigned long long)iblock, @@ -1688,16 +1595,20 @@ static int check_system_inode(struct gfs2_sbd *sdp, if (ds.q == GFS2_BLKST_FREE) { log_info( _("The inode exists but the block is not " "marked 'in use'; fixing it.\n")); - fsck_blockmap_set(*sysinode, - (*sysinode)->i_di.di_num.no_addr, + fsck_blockmap_set(*sysinode, (*sysinode)->i_addr, filename, GFS2_BLKST_DINODE); ds.q = GFS2_BLKST_DINODE; - if (isdir) - dirtree_insert((*sysinode)->i_di.di_num); + if (isdir) { + struct gfs2_inum no = { + .no_addr = (*sysinode)->i_addr, + .no_formal_ino = (*sysinode)->i_formal_ino + }; + dirtree_insert(no); + } } /* Make sure it's marked as a system file/directory */ if (needs_sysbit && - !((*sysinode)->i_di.di_flags & GFS2_DIF_SYSTEM)) { + !((*sysinode)->i_flags & GFS2_DIF_SYSTEM)) { log_err( _("System inode %s is missing the 'system' " "flag. It should be rebuilt.\n"), filename); if (sysdir && query(_("Delete the corrupt %s system " @@ -1737,23 +1648,27 @@ static int check_system_inode(struct gfs2_sbd *sdp, } if (*sysinode == sdp->md.jiinode) ji_update(sdp); - fsck_blockmap_set(*sysinode, - (*sysinode)->i_di.di_num.no_addr, + fsck_blockmap_set(*sysinode, (*sysinode)->i_addr, filename, GFS2_BLKST_DINODE); ds.q = GFS2_BLKST_DINODE; - if (isdir) - dirtree_insert((*sysinode)->i_di.di_num); + if (isdir) { + struct gfs2_inum no = { + .no_addr = (*sysinode)->i_addr, + .no_formal_ino = (*sysinode)->i_formal_ino + }; + dirtree_insert(no); + } } else { log_err( _("Cannot continue without valid %s inode\n"), filename); return -1; } } - if (is_dir(&(*sysinode)->i_di, sdp->gfs1)) { + if (is_dir(*sysinode, sdp->gfs1)) { struct block_count bc = {0};
sysdir_fxns.private = &bc; - if ((*sysinode)->i_di.di_flags & GFS2_DIF_EXHASH) + if ((*sysinode)->i_flags & GFS2_DIF_EXHASH) pass1_check_metatree(*sysinode, &sysdir_fxns); else { err = check_linear_dir(*sysinode, (*sysinode)->i_bh, @@ -1799,8 +1714,7 @@ static int check_system_inodes(struct gfs2_sbd *sdp) All other system dinodes in master will be taken care of by function resuscitate_metalist. But master won't since it has no parent.*/ if (!sdp->gfs1) { - fsck_blockmap_set(sdp->master_dir, - sdp->master_dir->i_di.di_num.no_addr, + fsck_blockmap_set(sdp->master_dir, sdp->master_dir->i_addr, "master", GFS2_BLKST_DINODE); if (check_system_inode(sdp, &sdp->master_dir, "master", build_master, 1, NULL, 1)) { @@ -1810,7 +1724,7 @@ static int check_system_inodes(struct gfs2_sbd *sdp) } /* Mark the root dinode as a "dinode" in the block map as we did for master, since it has no parent. */ - fsck_blockmap_set(sdp->md.rooti, sdp->md.rooti->i_di.di_num.no_addr, + fsck_blockmap_set(sdp->md.rooti, sdp->md.rooti->i_addr, "root", GFS2_BLKST_DINODE); if (check_system_inode(sdp, &sdp->md.rooti, "root", build_root, 1, NULL, 0)) { @@ -1855,17 +1769,22 @@ static int check_system_inodes(struct gfs2_sbd *sdp) journal_count = sdp->md.journals; /* gfs1's journals aren't dinode, they're just a bunch of blocks. */ if (sdp->gfs1) { + struct gfs2_inum no; /* gfs1 has four dinodes that are set in the superblock and therefore not linked to anything else. We need to adjust the link counts so pass4 doesn't get confused. */ - incr_link_count(sdp->md.statfs->i_di.di_num, NULL, - _("gfs1 statfs inode")); - incr_link_count(sdp->md.jiinode->i_di.di_num, NULL, - _("gfs1 jindex inode")); - incr_link_count(sdp->md.riinode->i_di.di_num, NULL, - _("gfs1 rindex inode")); - incr_link_count(sdp->md.qinode->i_di.di_num, NULL, - _("gfs1 quota inode")); + no.no_addr = sdp->md.statfs->i_addr; + no.no_formal_ino = sdp->md.statfs->i_formal_ino; + incr_link_count(no, NULL, _("gfs1 statfs inode")); + no.no_addr = sdp->md.jiinode->i_addr; + no.no_formal_ino = sdp->md.jiinode->i_formal_ino; + incr_link_count(no, NULL, _("gfs1 jindex inode")); + no.no_addr = sdp->md.riinode->i_addr; + no.no_formal_ino = sdp->md.riinode->i_formal_ino; + incr_link_count(no, NULL, _("gfs1 rindex inode")); + no.no_addr = sdp->md.qinode->i_addr; + no.no_formal_ino = sdp->md.qinode->i_formal_ino; + incr_link_count(no, NULL, _("gfs1 quota inode")); return 0; } for (sdp->md.journals = 0; sdp->md.journals < journal_count; @@ -1960,7 +1879,7 @@ static int pass1_process_bitmap(struct gfs2_sbd *sdp, struct rgrp_tree *rgd, uin (unsigned long long)block, block_type_string(q)); ip = fsck_inode_get(sdp, rgd, bh); - if (is_inode && ip->i_di.di_num.no_addr == block) + if (is_inode && ip->i_addr == block) add_duplicate_ref(ip, block, REF_IS_INODE, 0, INODE_VALID); else diff --git a/gfs2/fsck/pass1b.c b/gfs2/fsck/pass1b.c index a6f06ade..8d702959 100644 --- a/gfs2/fsck/pass1b.c +++ b/gfs2/fsck/pass1b.c @@ -328,11 +328,11 @@ static void resolve_dup_references(struct gfs2_sbd *sdp, struct duptree *dt, because it IS ours, and we need to remove all the eattr leaf blocks: they do belong to us (except for the duplicate referenced one, which is handled). */ - if (ip->i_di.di_eattr == dt->block) { - ip->i_di.di_eattr = 0; - if (ip->i_di.di_blocks > 0) - ip->i_di.di_blocks--; - ip->i_di.di_flags &= ~GFS2_DIF_EA_INDIRECT; + if (ip->i_eattr == dt->block) { + ip->i_eattr = 0; + if (ip->i_blocks > 0) + ip->i_blocks--; + ip->i_flags &= ~GFS2_DIF_EA_INDIRECT; bmodified(ip->i_bh); dup_listent_delete(dt, id); (dh->ref_inode_count)--; @@ -350,17 +350,17 @@ static void resolve_dup_references(struct gfs2_sbd *sdp, struct duptree *dt, and dirtree entries exist. That way, the bitmap_set will do proper accounting for the rgrp dinode count. */ - fsck_bitmap_set(ip, ip->i_di.di_num.no_addr, + fsck_bitmap_set(ip, ip->i_addr, _("duplicate referencing bad"), GFS2_BLKST_FREE); /* Remove the inode from the inode tree */ - ii = inodetree_find(ip->i_di.di_num.no_addr); + ii = inodetree_find(ip->i_addr); if (ii) inodetree_delete(ii); - di = dirtree_find(ip->i_di.di_num.no_addr); + di = dirtree_find(ip->i_addr); if (di) dirtree_delete(di); - link1_set(&nlink1map, ip->i_di.di_num.no_addr, + link1_set(&nlink1map, ip->i_addr, 0); /* We delete the dup_handler inode count and duplicate id BEFORE clearing the metadata, @@ -422,20 +422,15 @@ static int clone_data(struct gfs2_inode *ip, uint64_t metablock, return 0;
if (clonet->first) { - log_debug(_("Inode %lld (0x%llx)'s first reference to " - "block %lld (0x%llx) is targeted for cloning.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)block, - (unsigned long long)block); + log_debug(_("Inode %"PRIu64" (0x%"PRIx64")'s first reference to " + "block %"PRIu64" (0x%"PRIx64") is targeted for cloning.\n"), + ip->i_addr, ip->i_addr, block, block); clonet->first = 0; return 0; } - log_err(_("Error: Inode %lld (0x%llx)'s reference to block %lld " - "(0x%llx) should be replaced with a clone.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)block, (unsigned long long)block); + log_err(_("Error: Inode %"PRIu64" (0x%"PRIx64")'s reference to block %"PRIu64 + " (0x%"PRIx64") should be replaced with a clone.\n"), + ip->i_addr, ip->i_addr, block, block); if (query( _("Okay to clone the duplicated reference? (y/n) "))) { error = lgfs2_meta_alloc(ip, &cloneblock); if (!error) { @@ -496,16 +491,13 @@ static void clone_dup_ref_in_inode(struct gfs2_inode *ip, struct duptree *dt) .check_data = clone_data, };
- log_err(_("There are multiple references to block %lld (0x%llx) in " - "inode %lld (0x%llx)\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)dt->block, (unsigned long long)dt->block); + log_err(_("There are multiple references to block %"PRIu64" (0x%"PRIx64") in " + "inode %"PRIu64" (0x%"PRIx64")\n"), + ip->i_addr, ip->i_addr, dt->block, dt->block); error = check_metatree(ip, &pass1b_fxns_clone); if (error) { - log_err(_("Error cloning duplicate reference(s) to block %lld " - "(0x%llx).\n"), (unsigned long long)dt->block, - (unsigned long long)dt->block); + log_err(_("Error cloning duplicate reference(s) to block %"PRIu64 + " (0x%"PRIx64").\n"), dt->block, dt->block); } }
@@ -518,7 +510,7 @@ static int set_ip_bitmap(struct gfs2_inode *ip) if (ip->i_sbd->gfs1) mode = gfs_to_gfs2_mode(ip); else - mode = ip->i_di.di_mode & S_IFMT; + mode = ip->i_mode & S_IFMT;
switch (mode) { case S_IFDIR: @@ -590,7 +582,7 @@ static void resolve_last_reference(struct gfs2_sbd *sdp, struct duptree *dt, fsck_bitmap_set(ip, dt->block, _("reference-repaired data"), GFS2_BLKST_USED); } else if (id->reftypecount[REF_AS_META]) { - if (is_dir(&ip->i_di, sdp->gfs1)) + if (is_dir(ip, sdp->gfs1)) fsck_bitmap_set(ip, dt->block, _("reference-repaired leaf"), sdp->gfs1 ? GFS2_BLKST_DINODE : @@ -621,9 +613,9 @@ static void resolve_last_reference(struct gfs2_sbd *sdp, struct duptree *dt, "(y/n) "), (unsigned long long)id->block_no, (unsigned long long)id->block_no)) { - ip->i_di.di_eattr = 0; - ip->i_di.di_flags &= ~GFS2_DIF_EA_INDIRECT; - ip->i_di.di_blocks--; + ip->i_eattr = 0; + ip->i_flags &= ~GFS2_DIF_EA_INDIRECT; + ip->i_blocks--; bmodified(ip->i_bh); fsck_bitmap_set(ip, dt->block, _("reference-repaired EA"), @@ -882,8 +874,8 @@ static int find_block_ref(struct gfs2_sbd *sdp, uint64_t inode) ip = fsck_load_inode(sdp, inode); /* bread, inode_get */
/* double-check the meta header just to be sure it's metadata */ - if (ip->i_di.di_header.mh_magic != GFS2_MAGIC || - ip->i_di.di_header.mh_type != GFS2_METATYPE_DI) { + if (ip->i_magic != GFS2_MAGIC || + ip->i_type != GFS2_METATYPE_DI) { if (!sdp->gfs1) log_debug( _("Block %lld (0x%llx) is not a dinode.\n"), (unsigned long long)inode, diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c index e595051d..d5fe61b3 100644 --- a/gfs2/fsck/pass2.c +++ b/gfs2/fsck/pass2.c @@ -92,7 +92,7 @@ static int set_dotdot_dir(struct gfs2_sbd *sdp, uint64_t childblock, } /* Special case for root inode because we set it earlier */ if (di->dotdot_parent.no_addr && - sdp->md.rooti->i_di.di_num.no_addr != di->dinode.no_addr) { + sdp->md.rooti->i_addr != di->dinode.no_addr) { /* This should never happen */ log_crit( _("Dotdot parent already set for block %llu (0x%llx)" "-> %llu (0x%llx)\n"), @@ -199,17 +199,15 @@ static int bad_formal_ino(struct gfs2_inode *ip, struct gfs2_dirent *dent, struct gfs2_inode *dent_ip;
dent_ip = fsck_load_inode(ip->i_sbd, entry.no_addr); - inum = dent_ip->i_di.di_num; + inum.no_addr = dent_ip->i_addr; + inum.no_formal_ino = dent_ip->i_formal_ino; fsck_inode_put(&dent_ip); } } - log_err( _("Directory entry '%s' pointing to block %llu (0x%llx) in " - "directory %llu (0x%llx) has the wrong 'formal' inode " - "number.\n"), tmp_name, (unsigned long long)entry.no_addr, - (unsigned long long)entry.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); - log_err( _("The directory entry has %llu (0x%llx) but the inode has " + log_err(_("Directory entry '%s' pointing to block %"PRIu64" (0x%"PRIx64") in " + "directory %"PRIu64" (0x%"PRIx64") has the wrong 'formal' inode number.\n"), + tmp_name, entry.no_addr, entry.no_addr, ip->i_addr, ip->i_addr); + log_err(_("The directory entry has %llu (0x%llx) but the inode has " "%llu (0x%llx)\n"), (unsigned long long)entry.no_formal_ino, (unsigned long long)entry.no_formal_ino, (unsigned long long)inum.no_formal_ino, @@ -225,17 +223,20 @@ static int bad_formal_ino(struct gfs2_inode *ip, struct gfs2_dirent *dent, has a '..' pointing back, just fix up the no_formal_ino. */ child_ip = lgfs2_inode_read(sdp, entry.no_addr); error = dir_search(child_ip, "..", 2, NULL, &childs_dotdot); - if (!error && childs_dotdot.no_addr == ip->i_di.di_num.no_addr) { + if (!error && childs_dotdot.no_addr == ip->i_addr) { log_err( _("The entry points to another directory with intact " "linkage.\n")); if (query( _("Fix the bad directory entry? (y/n) "))) { + struct gfs2_inum no; log_err( _("Fixing the corrupt directory entry.\n")); entry.no_formal_ino = inum.no_formal_ino; de->de_inum.no_formal_ino = entry.no_formal_ino; gfs2_dirent_out(de, (char *)dent); bmodified(bh); incr_link_count(entry, ip, _("fixed reference")); - set_parent_dir(sdp, entry, ip->i_di.di_num); + no.no_addr = ip->i_addr; + no.no_formal_ino = ip->i_formal_ino; + set_parent_dir(sdp, entry, no); } else { log_err( _("Directory entry not fixed.\n")); } @@ -252,14 +253,14 @@ static int bad_formal_ino(struct gfs2_inode *ip, struct gfs2_dirent *dent,
static int hash_table_index(uint32_t hash, struct gfs2_inode *ip) { - return hash >> (32 - ip->i_di.di_depth); + return hash >> (32 - ip->i_depth); }
static int hash_table_max(int lindex, struct gfs2_inode *ip, struct gfs2_buffer_head *bh) { struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data; - return (1 << (ip->i_di.di_depth - be16_to_cpu(leaf->lf_depth))) + + return (1 << (ip->i_depth - be16_to_cpu(leaf->lf_depth))) + lindex - 1; }
@@ -268,7 +269,7 @@ static int check_leaf_depth(struct gfs2_inode *ip, uint64_t leaf_no, { struct gfs2_leaf *leaf = (struct gfs2_leaf *)lbh->b_data; int cur_depth = be16_to_cpu(leaf->lf_depth); - int exp_count = 1 << (ip->i_di.di_depth - cur_depth); + int exp_count = 1 << (ip->i_depth - cur_depth); int divisor; int factor, correct_depth;
@@ -281,20 +282,17 @@ static int check_leaf_depth(struct gfs2_inode *ip, uint64_t leaf_no, factor++; divisor >>= 1; } - if (ip->i_di.di_depth < factor) /* can't be fixed--leaf must be on the + if (ip->i_depth < factor) /* can't be fixed--leaf must be on the wrong dinode. */ return -1; - correct_depth = ip->i_di.di_depth - factor; + correct_depth = ip->i_depth - factor; if (cur_depth == correct_depth) return 0;
- log_err(_("Leaf block %llu (0x%llx) in dinode %llu (0x%llx) has the " - "wrong depth: is %d (length %d), should be %d (length " - "%d).\n"), - (unsigned long long)leaf_no, (unsigned long long)leaf_no, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - cur_depth, ref_count, correct_depth, exp_count); + log_err(_("Leaf block %"PRIu64" (0x%"PRIx64") in dinode %"PRIu64" (0x%"PRIx64") has the " + "wrong depth: is %d (length %d), should be %d (length %d).\n"), + leaf_no, leaf_no, ip->i_addr, ip->i_addr, + cur_depth, ref_count, correct_depth, exp_count); if (!query( _("Fix the leaf block? (y/n)"))) { log_err( _("The leaf block was not fixed.\n")); return 0; @@ -351,7 +349,7 @@ static int wrong_leaf(struct gfs2_inode *ip, struct gfs2_inum *entry, (unsigned long long)planned_leaf); /* Can't trust lf_depth; we have to count */ dest_ref = 0; - for (li = 0; li < (1 << ip->i_di.di_depth); li++) { + for (li = 0; li < (1 << ip->i_depth); li++) { if (be64_to_cpu(tbl[li]) == planned_leaf) dest_ref++; else if (dest_ref) @@ -372,26 +370,24 @@ static int wrong_leaf(struct gfs2_inode *ip, struct gfs2_inum *entry, return 1; /* nuke the dent upon return */ }
- di_depth = ip->i_di.di_depth; + di_depth = ip->i_depth; if (dir_add(ip, tmp_name, de->de_name_len, &de->de_inum, de->de_type) == 0) { log_err(_("The misplaced directory entry was moved to a " "valid leaf block.\n")); - if (ip->i_di.di_depth > di_depth) { + if (ip->i_depth > di_depth) { log_err(_("Directory hash table was doubled.\n")); - hash_index <<= (ip->i_di.di_depth - di_depth); - (*lindex) <<= (ip->i_di.di_depth - di_depth); + hash_index <<= (ip->i_depth - di_depth); + (*lindex) <<= (ip->i_depth - di_depth); } if (lgfs2_get_leaf_ptr(ip, hash_index, &real_leaf)) { log_err(_("Could not read leaf %d in dinode %"PRIu64": %s\n"), hash_index, - (uint64_t)ip->i_di.di_num.no_addr, strerror(errno)); + ip->i_addr, strerror(errno)); } if (real_leaf != planned_leaf) { log_err(_("The planned leaf was split. The new leaf " - "is: %llu (0x%llx). di_blocks=%llu\n"), - (unsigned long long)real_leaf, - (unsigned long long)real_leaf, - (unsigned long long)ip->i_di.di_blocks); + "is: %"PRIu64" (0x%"PRIx64"). di_blocks=%"PRIu64"\n"), + real_leaf, real_leaf, ip->i_blocks); fsck_bitmap_set(ip, real_leaf, _("split leaf"), sdp->gfs1 ? GFS2_BLKST_DINODE : GFS2_BLKST_USED); @@ -411,8 +407,11 @@ static int wrong_leaf(struct gfs2_inode *ip, struct gfs2_inum *entry, to nuke the dent from this leaf when we return, but we still need to do the "good dent" accounting. */ if (de->de_type == (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR)) { - error = set_parent_dir(sdp, de->de_inum, - ip->i_di.di_num); + struct gfs2_inum no = { + .no_addr = ip->i_addr, + .no_formal_ino = ip->i_formal_ino + }; + error = set_parent_dir(sdp, de->de_inum, no); if (error > 0) /* This is a bit of a kludge, but returning 0 in this case causes the caller to go through @@ -467,12 +466,10 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
*isdir = 0; if (!valid_block_ip(ip, entry->no_addr)) { - log_err( _("Block # referenced by directory entry %s in inode " - "%lld (0x%llx) is invalid\n"), - tmp_name, (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); - if (query( _("Clear directory entry to out of range block? " - "(y/n) "))) { + log_err(_("Block # referenced by directory entry %s in inode %"PRIu64 + " (0x%"PRIx64") is invalid\n"), + tmp_name, ip->i_addr, ip->i_addr); + if (query( _("Clear directory entry to out of range block? (y/n) "))) { return 1; } else { log_err( _("Directory entry to out of range block remains\n")); @@ -540,19 +537,14 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent, * metadata tree deleted. */ if (*q != GFS2_BLKST_DINODE) { - log_err( _("Directory entry '%s' referencing inode %llu " - "(0x%llx) in dir inode %llu (0x%llx) block type " - "%d: %s.\n"), tmp_name, - (unsigned long long)entry->no_addr, - (unsigned long long)entry->no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, + log_err(_("Directory entry '%s' referencing inode %"PRIu64" (0x%"PRIx64") " + "in dir inode %"PRIu64" (0x%"PRIx64") block type %d: %s.\n"), + tmp_name, entry->no_addr, entry->no_addr, ip->i_addr, ip->i_addr, *q, *q == GFS2_BLKST_FREE ? _("was previously marked invalid") : _("was deleted or is not an inode"));
- if (!query( _("Clear directory entry to non-inode block? " - "(y/n) "))) { + if (!query(_("Clear directory entry to non-inode block? (y/n) "))) { log_err( _("Directory entry to non-inode block remains\n")); return 0; } @@ -579,13 +571,9 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent, error = check_file_type(entry->no_addr, de->de_type, *q, sdp->gfs1, isdir); if (error < 0) { - log_err( _("Error: directory entry type is " - "incompatible with block type at block %lld " - "(0x%llx) in directory inode %llu (0x%llx).\n"), - (unsigned long long)entry->no_addr, - (unsigned long long)entry->no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Error: directory entry type is incompatible with block type at block %"PRIu64 + " (0x%"PRIx64") in directory inode %"PRIu64" (0x%"PRIx64").\n"), + entry->no_addr, entry->no_addr, ip->i_addr, ip->i_addr); log_err( _("Directory entry type is %d, block type is %d.\n"), de->de_type, *q); stack; @@ -602,7 +590,7 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent, log_err( _("Stale directory entry remains\n")); return 0; } - if (ip->i_di.di_num.no_addr == entry->no_addr) + if (ip->i_addr == entry->no_addr) entry_ip = ip; else entry_ip = fsck_load_inode(sdp, entry->no_addr); @@ -628,19 +616,13 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent, } } if (inum.no_formal_ino != entry->no_formal_ino) { - log_err( _("Directory entry '%s' pointing to block %llu " - "(0x%llx) in directory %llu (0x%llx) has the " - "wrong 'formal' inode number.\n"), tmp_name, - (unsigned long long)entry->no_addr, - (unsigned long long)entry->no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); - log_err( _("The directory entry has %llu (0x%llx) but the " - "inode has %llu (0x%llx)\n"), - (unsigned long long)entry->no_formal_ino, - (unsigned long long)entry->no_formal_ino, - (unsigned long long)inum.no_formal_ino, - (unsigned long long)inum.no_formal_ino); + log_err(_("Directory entry '%s' pointing to block %"PRIu64" (0x%"PRIx64") " + "in directory %"PRIu64" (0x%"PRIx64") has the wrong 'formal' inode number.\n"), + tmp_name, entry->no_addr, entry->no_addr, ip->i_addr, ip->i_addr); + log_err(_("The directory entry has %"PRIu64" (0x%"PRIx64") but the " + "inode has %"PRIu64" (0x%"PRIx64")\n"), + entry->no_formal_ino, entry->no_formal_ino, + inum.no_formal_ino, inum.no_formal_ino); return 1; } /* Check for a special case where a (bad) GFS1 dirent points to what @@ -652,13 +634,10 @@ static int basic_dentry_checks(struct gfs2_inode *ip, struct gfs2_dirent *dent,
tbh = bread(sdp, entry->no_addr); if (gfs2_check_meta(tbh->b_data, GFS2_METATYPE_DI)) { /* not dinode */ - log_err( _("Directory entry '%s' pointing to block " - "%llu (0x%llx) in directory %llu (0x%llx) " + log_err(_("Directory entry '%s' pointing to block %"PRIu64 + " (0x%"PRIx64") in directory %"PRIu64" (0x%"PRIx64") " "is not really a GFS1 dinode.\n"), tmp_name, - (unsigned long long)entry->no_addr, - (unsigned long long)entry->no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + entry->no_addr, entry->no_addr, ip->i_addr, ip->i_addr); brelse(tbh); return 1; } @@ -691,12 +670,9 @@ static int dirref_find(struct gfs2_inode *ip, struct gfs2_dirent *dent, "link.\n"); goto out; } - log_err(_("The original reference to inode %lld (0x%llx) from " - "directory %lld (0x%llx) has the wrong 'formal' inode " - "number.\n"), (unsigned long long)entry->no_addr, - (unsigned long long)entry->no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("The original reference to inode %"PRIu64" (0x%"PRIx64") from " + "directory %"PRIu64" (0x%"PRIx64") has the wrong 'formal' inode " + "number.\n"), entry->no_addr, entry->no_addr, ip->i_addr, ip->i_addr); memset(fn, 0, sizeof(fn)); if (de->de_name_len < MAX_FILENAME) strncpy(fn, filename, de->de_name_len); @@ -712,8 +688,8 @@ static int dirref_find(struct gfs2_inode *ip, struct gfs2_dirent *dent, log_err(_("The corrupt directory entry was not fixed.\n")); goto out; } - decr_link_count(entry->no_addr, ip->i_di.di_num.no_addr, - ip->i_sbd->gfs1, _("bad original reference")); + decr_link_count(entry->no_addr, ip->i_addr, ip->i_sbd->gfs1, + _("bad original reference")); dirent2_del(ip, bh, prev, dent); log_err(_("The corrupt directory entry '%s' was deleted.\n"), fn); out: @@ -784,7 +760,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, struct gfs2_sbd *sdp = ip->i_sbd; int q = 0; char tmp_name[MAX_FILENAME]; - struct gfs2_inum entry; + struct gfs2_inum entry, no; struct dir_status *ds = (struct dir_status *) priv; int error; struct gfs2_inode *entry_ip = NULL; @@ -813,22 +789,19 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, goto nuke_dentry;
if (!strcmp(".", tmp_name)) { - log_debug( _("Found . dentry in directory %lld (0x%llx)\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_debug(_("Found . dentry in directory %"PRIu64" (0x%"PRIx64")\n"), + ip->i_addr, ip->i_addr);
if (ds->dotdir) { - log_err( _("Already found '.' entry in directory %llu" - " (0x%llx)\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Already found '.' entry in directory %"PRIu64" (0x%"PRIx64")\n"), + ip->i_addr, ip->i_addr); if (!query( _("Clear duplicate '.' entry? (y/n) "))) { log_err( _("Duplicate '.' entry remains\n")); /* FIXME: Should we continue on here * and check the rest of the '.' entry? */ goto dentry_is_valid; } - if (ip->i_di.di_num.no_addr == entry.no_addr) + if (ip->i_addr == entry.no_addr) entry_ip = ip; else entry_ip = fsck_load_inode(sdp, entry.no_addr); @@ -842,24 +815,19 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, * location */
/* check that '.' refers to this inode */ - if (entry.no_addr != ip->i_di.di_num.no_addr) { - log_err( _("'.' entry's value incorrect in directory %llu" - " (0x%llx). Points to %llu" - " (0x%llx) when it should point to %llu" - " (0x%llx).\n"), - (unsigned long long)entry.no_addr, - (unsigned long long)entry.no_addr, - (unsigned long long)entry.no_addr, - (unsigned long long)entry.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + if (entry.no_addr != ip->i_addr) { + log_err(_("'.' entry's value incorrect in directory %"PRIu64" (0x%"PRIx64")." + " Points to %"PRIu64" (0x%"PRIx64") when it should point to %"PRIu64 + " (0x%"PRIx64").\n"), + entry.no_addr, entry.no_addr, entry.no_addr, entry.no_addr, + ip->i_addr, ip->i_addr); if (!query( _("Remove '.' reference? (y/n) "))) { log_err( _("Invalid '.' reference remains\n")); /* Not setting ds->dotdir here since * this '.' entry is invalid */ goto dentry_is_valid; } - if (ip->i_di.di_num.no_addr == entry.no_addr) + if (ip->i_addr == entry.no_addr) entry_ip = ip; else entry_ip = fsck_load_inode(sdp, entry.no_addr); @@ -873,14 +841,11 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, goto dentry_is_valid; } if (!strcmp("..", tmp_name)) { - log_debug( _("Found '..' dentry in directory %lld (0x%llx)\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_debug(_("Found '..' dentry in directory %"PRIu64" (0x%"PRIx64")\n"), + ip->i_addr, ip->i_addr); if (ds->dotdotdir) { - log_err( _("Already had a '..' entry in directory %llu" - "(0x%llx)\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Already had a '..' entry in directory %"PRIu64" (0x%"PRIx64")\n"), + ip->i_addr, ip->i_addr); if (!query( _("Clear duplicate '..' entry? (y/n) "))) { log_err( _("Duplicate '..' entry remains\n")); /* FIXME: Should we continue on here @@ -889,7 +854,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, goto dentry_is_valid; }
- if (ip->i_di.di_num.no_addr == entry.no_addr) + if (ip->i_addr == entry.no_addr) entry_ip = ip; else entry_ip = fsck_load_inode(sdp, entry.no_addr); @@ -900,15 +865,14 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, goto nuke_dentry; } if (!isdir) { - log_err( _("Found '..' entry in directory %llu (0x%llx) " + log_err(_("Found '..' entry in directory %"PRIu64" (0x%"PRIx64") " "pointing to something that's not a directory"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + ip->i_addr, ip->i_addr); if (!query( _("Clear bad '..' directory entry? (y/n) "))) { log_err( _("Bad '..' directory entry remains\n")); goto dentry_is_valid; } - if (ip->i_di.di_num.no_addr == entry.no_addr) + if (ip->i_addr == entry.no_addr) entry_ip = ip; else entry_ip = fsck_load_inode(sdp, entry.no_addr); @@ -923,7 +887,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, /* Add the address this entry is pointing to * to this inode's dotdot_parent in * dir_info */ - if (set_dotdot_dir(sdp, ip->i_di.di_num.no_addr, entry)) { + if (set_dotdot_dir(sdp, ip->i_addr, entry)) { stack; return -1; } @@ -933,7 +897,7 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, } /* If this is an exhash directory, make sure the dentries in the leaf block have a hash table index that fits */ - if (ip->i_di.di_flags & GFS2_DIF_EXHASH) { + if (ip->i_flags & GFS2_DIF_EXHASH) { hash_index = hash_table_index(de->de_hash, ip); lindex_max = hash_table_max(*lindex, ip, bh); if (hash_index < *lindex || hash_index > lindex_max) { @@ -957,7 +921,9 @@ static int check_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent, }
/*log_debug( _("Found plain directory dentry\n"));*/ - error = set_parent_dir(sdp, entry, ip->i_di.di_num); + no.no_addr = ip->i_addr; + no.no_formal_ino = ip->i_formal_ino; + error = set_parent_dir(sdp, entry, no); if (error > 0) { log_err( _("%s: Hard link to block %llu (0x%llx" ") detected.\n"), tmp_name, @@ -1026,10 +992,8 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex, /* Make sure the number of copies is properly a factor of 2 */ if ((1 << factor) != num_copies) { log_err(_("Program error: num_copies not a factor of 2.\n")); - log_err(_("num_copies=%d, dinode = %lld (0x%llx)\n"), - num_copies, - (unsigned long long)dip->i_di.di_num.no_addr, - (unsigned long long)dip->i_di.di_num.no_addr); + log_err(_("num_copies=%d, dinode = %"PRIu64" (0x%"PRIx64")\n"), + num_copies, dip->i_addr, dip->i_addr); log_err(_("lindex = %d (0x%x)\n"), start_lindex, start_lindex); stack; free(padbuf); @@ -1050,7 +1014,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex, "pointer at index %d (0x%x).\n"), (unsigned long long)*bn, (unsigned long long)*bn, num_copies, num_copies, before_or_after, start_lindex, start_lindex); - dip->i_di.di_blocks++; + dip->i_blocks++; bmodified(dip->i_bh); nbh = bget(dip->i_sbd, *bn); memset(nbh->b_data, 0, dip->i_sbd->bsize); @@ -1058,7 +1022,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex, leaf->lf_header.mh_magic = cpu_to_be32(GFS2_MAGIC); leaf->lf_header.mh_type = cpu_to_be32(GFS2_METATYPE_LF); leaf->lf_header.mh_format = cpu_to_be32(GFS2_FORMAT_LF); - leaf->lf_depth = cpu_to_be16(dip->i_di.di_depth - factor); + leaf->lf_depth = cpu_to_be16(dip->i_depth - factor);
/* initialize the first dirent on the new leaf block */ dent = (struct gfs2_dirent *)(nbh->b_data + sizeof(struct gfs2_leaf)); @@ -1074,10 +1038,9 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex, cpyptr++; } pad_size = num_copies * sizeof(uint64_t); - log_err(_("Writing to the hash table of directory %lld " - "(0x%llx) at index: 0x%x for 0x%lx pointers.\n"), - (unsigned long long)dip->i_di.di_num.no_addr, - (unsigned long long)dip->i_di.di_num.no_addr, + log_err(_("Writing to the hash table of directory %"PRIu64 + " (0x%"PRIx64") at index: 0x%x for 0x%lx pointers.\n"), + dip->i_addr, dip->i_addr, start_lindex, (unsigned long)pad_size / sizeof(uint64_t)); if (dip->i_sbd->gfs1) count = gfs1_writei(dip, padbuf, start_lindex * @@ -1108,11 +1071,9 @@ static void pad_with_leafblks(struct gfs2_inode *ip, uint64_t *tbl, uint32_t proper_start = lindex; uint64_t new_leaf_blk;
- log_err(_("Padding inode %llu (0x%llx) hash table at offset %d (0x%x) " - "for %d pointers.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, lindex, lindex, - len); + log_err(_("Padding inode %"PRIu64" (0x%"PRIx64") hash table at offset %d (0x%x) " + "for %d pointers.\n"), + ip->i_addr, ip->i_addr, lindex, lindex, len); while (len) { new_len = 1; /* Determine the next factor of 2 down from extras. We can't @@ -1205,6 +1166,7 @@ static int lost_leaf(struct gfs2_inode *ip, uint64_t *tbl, uint64_t leafno, log_err(_("Not relocating corrupt entry " ""%s".\n"), tmp_name); } else { + error = dir_add(lf_dip, filename, de.de_name_len, &de.de_inum, de.de_type); @@ -1220,10 +1182,13 @@ static int lost_leaf(struct gfs2_inode *ip, uint64_t *tbl, uint64_t leafno, _("from lost+found")); /* If it's a directory, lost+found is back-linked to it via .. */ - if (isdir) - incr_link_count(lf_dip->i_di.di_num, - NULL, - _("to lost+found")); + if (isdir) { + struct gfs2_inum no = { + .no_addr = lf_dip->i_addr, + .no_formal_ino = lf_dip->i_formal_ino + }; + incr_link_count(no, NULL, _("to lost+found")); + } log_err(_("Relocated "%s", block %llu " "(0x%llx) to lost+found.\n"), tmp_name, @@ -1239,7 +1204,7 @@ static int lost_leaf(struct gfs2_inode *ip, uint64_t *tbl, uint64_t leafno, "to lost+found.\n")); /* Free the lost leaf. */ fsck_bitmap_set(ip, leafno, _("lost leaf"), GFS2_BLKST_FREE); - ip->i_di.di_blocks--; + ip->i_blocks--; bmodified(ip->i_bh); /* Now we have to deal with the bad hash table entries pointing to the misplaced leaf block. But we can't just fill the gap with a single @@ -1300,12 +1265,8 @@ static int pass2_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no, int new_leaf_blks = 0, error, refs; uint64_t bn = 0;
- log_err( _("Directory Inode %llu (0x%llx) points to leaf %llu" - " (0x%llx) %s.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)*leaf_no, - (unsigned long long)*leaf_no, msg); + log_err(_("Directory Inode %"PRIu64" (0x%"PRIx64") points to leaf %"PRIu64" (0x%"PRIx64") %s.\n"), + ip->i_addr, ip->i_addr, *leaf_no, *leaf_no, msg); if (!query( _("Attempt to patch around it? (y/n) "))) { log_err( _("Bad leaf left in place.\n")); goto out; @@ -1329,9 +1290,8 @@ static int pass2_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no, lindex += refs; ref_count -= refs; } - log_err( _("Directory Inode %llu (0x%llx) repaired.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_err(_("Directory Inode %"PRIu64" (0x%"PRIx64") repaired.\n"), + ip->i_addr, ip->i_addr); out: *leaf_no = bn; return new_leaf_blks; @@ -1390,11 +1350,9 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize, uint32_t leaf_proper_start;
*proper_len = len; - log_err(_("Dinode %llu (0x%llx) has a hash table error at index " - "0x%x, length 0x%x: leaf block %llu (0x%llx)\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, lindex, len, - (unsigned long long)leafblk, (unsigned long long)leafblk); + log_err(_("Dinode %"PRIu64" (0x%"PRIx64") has a hash table error at index " + "0x%x, length 0x%x: leaf block %"PRIu64" (0x%"PRIx64")\n"), + ip->i_addr, ip->i_addr, lindex, len, leafblk, leafblk); if (!query( _("Fix the hash table? (y/n) "))) { log_err(_("Hash table not fixed.\n")); return 0; @@ -1410,10 +1368,10 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize, lbh = bread(ip->i_sbd, leafblk); /* If the leaf's depth is out of range for this dinode, it's obviously attached to the wrong dinode. Move the dirents to lost+found. */ - if (leaf.lf_depth > ip->i_di.di_depth) { + if (leaf.lf_depth > ip->i_depth) { log_err(_("This leaf block's depth (%d) is too big for this " "dinode's depth (%d)\n"), - leaf.lf_depth, ip->i_di.di_depth); + leaf.lf_depth, ip->i_depth); error = lost_leaf(ip, tbl, leafblk, len, lindex, lbh); brelse(lbh); return error; @@ -1439,7 +1397,7 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize, }
/* Calculate the proper number of pointers based on the leaf depth. */ - *proper_len = 1 << (ip->i_di.di_depth - leaf.lf_depth); + *proper_len = 1 << (ip->i_depth - leaf.lf_depth);
/* Look at the first dirent and check its hash value to see if it's at the proper starting offset. */ @@ -1474,7 +1432,7 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize, already at its maximum depth. */ if ((leaf_proper_start < proper_start) || ((*proper_len > len || lindex > leaf_proper_start) && - leaf.lf_depth == ip->i_di.di_depth)) { + leaf.lf_depth == ip->i_depth)) { log_err(_("Leaf block should start at 0x%x, but it appears at " "0x%x in the hash table.\n"), leaf_proper_start, proper_start); @@ -1489,7 +1447,7 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize, later than they should, we can split the leaf to give it a smaller footprint in the hash table. */ if ((*proper_len > len || lindex > leaf_proper_start) && - ip->i_di.di_depth > leaf.lf_depth) { + ip->i_depth > leaf.lf_depth) { log_err(_("For depth %d, length %d, the proper start is: " "0x%x.\n"), factor, len, proper_start); changes++; @@ -1497,14 +1455,14 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl, unsigned hsize, dir_split_leaf(ip, lindex, leafblk, lbh); /* re-read the leaf to pick up dir_split_leaf's changes */ gfs2_leaf_in(&leaf, lbh->b_data); - *proper_len = 1 << (ip->i_di.di_depth - leaf.lf_depth); + *proper_len = 1 << (ip->i_depth - leaf.lf_depth); log_err(_("Leaf block %llu (0x%llx) was split from length " "%d to %d\n"), (unsigned long long)leafblk, (unsigned long long)leafblk, len, *proper_len); if (*proper_len < 0) { log_err(_("Programming error: proper_len=%d, " "di_depth = %d, lf_depth = %d.\n"), - *proper_len, ip->i_di.di_depth, leaf.lf_depth); + *proper_len, ip->i_depth, leaf.lf_depth); exit(FSCK_ERROR); } log_err(_("New split-off leaf block was allocated at %lld " @@ -1583,14 +1541,11 @@ static int check_hash_tbl_dups(struct gfs2_inode *ip, uint64_t *tbl, if (be64_to_cpu(tbl[l + len2]) != leafblk) break; } - log_err(_("Dinode %llu (0x%llx) has duplicate leaf pointers " - "to block %llu (0x%llx) at offsets %u (0x%x) " + log_err(_("Dinode %"PRIu64" (0x%"PRIx64") has duplicate leaf pointers " + "to block %"PRIu64" (0x%"PRIx64") at offsets %u (0x%x) " "(for 0x%x) and %u (0x%x) (for 0x%x)\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)leafblk, - (unsigned long long)leafblk, lindex, lindex, len, - l, l, len2); + ip->i_addr, ip->i_addr, leafblk, leafblk, lindex, lindex, + len, l, l, len2);
/* See which set of references is valid: the one passed in or the duplicate we found. */ @@ -1624,7 +1579,7 @@ static int check_hash_tbl_dups(struct gfs2_inode *ip, uint64_t *tbl, may have been correct without the duplicates but pass1 would have counted them and adjusted the count to include them. So we must subtract them. */ - ip->i_di.di_blocks--; + ip->i_blocks--; bmodified(ip->i_bh); pad_with_leafblks(ip, tbl, l, len2); } else { @@ -1644,7 +1599,7 @@ static int check_hash_tbl_dups(struct gfs2_inode *ip, uint64_t *tbl, log_err(_("Hash table not fixed.\n")); return 0; } - ip->i_di.di_blocks--; + ip->i_blocks--; bmodified(ip->i_bh); pad_with_leafblks(ip, tbl, lindex, len); /* At this point we know both copies are bad, so we @@ -1732,11 +1687,9 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl, if (!valid_block_ip(ip, leafblk)) { uint64_t new_leafblk;
- log_err(_("Dinode %llu (0x%llx) has bad leaf pointers " + log_err(_("Dinode %"PRIu64" (0x%"PRIx64") has bad leaf pointers " "at offset %d for %d\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - lindex, len); + ip->i_addr, ip->i_addr, lindex, len); if (!query( _("Fix the hash table? (y/n) "))) { log_err(_("Hash table not fixed.\n")); lindex += len; @@ -1795,7 +1748,7 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl, lbh = bread(ip->i_sbd, leafblk); gfs2_leaf_in(&leaf, lbh->b_data); if (gfs2_check_meta(lbh->b_data, GFS2_METATYPE_LF) || - leaf.lf_depth > ip->i_di.di_depth) + leaf.lf_depth > ip->i_depth) leaf.lf_depth = factor; brelse(lbh); changes = fix_hashtable(ip, tbl, hsize, leafblk, @@ -1820,10 +1773,9 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl, if (be64_to_cpu(tbl[i]) == leafblk) /* No problem */ continue;
- log_err(_("Dinode %llu (0x%llx) has a hash table " + log_err(_("Dinode %"PRIu64" (0x%"PRIx64") has a hash table " "inconsistency at index %d (0x%x) for %d\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, + ip->i_addr, ip->i_addr, i, i, len); if (!query( _("Fix the hash table? (y/n) "))) { log_err(_("Hash table not fixed.\n")); @@ -1837,7 +1789,7 @@ static int check_hash_tbl(struct gfs2_inode *ip, uint64_t *tbl, brelse(lbh); /* Calculate the expected pointer count based on the leaf depth. */ - proper_len = 1 << (ip->i_di.di_depth - leaf.lf_depth); + proper_len = 1 << (ip->i_depth - leaf.lf_depth); if (proper_len != len) { log_debug(_("Length 0x%x is not proper for " "leaf %llu (0x%llx): 0x%x\n"), @@ -1940,15 +1892,15 @@ static int check_pernode_for(int x, struct gfs2_inode *pernode, const char *fn, return 0; goto build_it; } - if (!ip->i_di.di_size) + if (!ip->i_size) valid_size = 0; - else if (!multiple && ip->i_di.di_size != filelen) + else if (!multiple && ip->i_size != filelen) valid_size = 0; - else if (multiple && (ip->i_di.di_size % filelen)) + else if (multiple && (ip->i_size % filelen)) valid_size = 0; if (!valid_size) { log_err(_("System file %s has an invalid size. Is %"PRIu64", " - "should be %llu.\n"), fn, ip->i_di.di_size, filelen); + "should be %llu.\n"), fn, ip->i_size, filelen); if (!query( _("Rebuild the system file? (y/n) "))) goto out_good; fsck_inode_put(&ip); @@ -1980,7 +1932,7 @@ build_it: log_err(_("Error rebuilding %s.\n"), fn); return -1; } - fsck_bitmap_set(ip, ip->i_di.di_num.no_addr, fn, GFS2_BLKST_DINODE); + fsck_bitmap_set(ip, ip->i_addr, fn, GFS2_BLKST_DINODE); log_err(_("System file %s rebuilt.\n"), fn); goto out_good; } @@ -2002,7 +1954,7 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname, return -1; }
- iblock = sysinode->i_di.di_num.no_addr; + iblock = sysinode->i_addr; ds.q = bitmap_type(sysinode->i_sbd, iblock);
pass2_fxns.private = (void *) &ds; @@ -2031,8 +1983,12 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname, if (!ds.dotdir) { log_err( _("No '.' entry found for %s directory.\n"), dirname); if (query( _("Is it okay to add '.' entry? (y/n) "))) { + struct gfs2_inum no = { + .no_addr = sysinode->i_addr, + .no_formal_ino = sysinode->i_formal_ino + }; log_warn( _("Adding '.' entry\n")); - error = dir_add(sysinode, ".", 1, &(sysinode->i_di.di_num), + error = dir_add(sysinode, ".", 1, &no, (sysinode->i_sbd->gfs1 ? GFS_FILE_DIR : DT_DIR)); if (error) { log_err(_("Error adding directory %s: %s\n"), "'.'", @@ -2040,32 +1996,23 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname, return -errno; } /* This system inode is linked to itself via '.' */ - incr_link_count(sysinode->i_di.di_num, sysinode, - "sysinode ".""); + incr_link_count(no, sysinode, "sysinode ".""); ds.entry_count++; } else log_err( _("The directory was not fixed.\n")); } - if (sysinode->i_di.di_entries != ds.entry_count) { - log_err( _("%s inode %llu (0x%llx" - "): Entries is %d - should be %d\n"), dirname, - (unsigned long long)sysinode->i_di.di_num.no_addr, - (unsigned long long)sysinode->i_di.di_num.no_addr, - sysinode->i_di.di_entries, ds.entry_count); - if (query( _("Fix entries for %s inode %llu (0x%llx)? (y/n) "), - dirname, - (unsigned long long)sysinode->i_di.di_num.no_addr, - (unsigned long long)sysinode->i_di.di_num.no_addr)) { - sysinode->i_di.di_entries = ds.entry_count; + if (sysinode->i_entries != ds.entry_count) { + log_err(_("%s inode %"PRIu64" (0x%"PRIx64"): Entries is %d - should be %d\n"), + dirname, sysinode->i_addr, sysinode->i_addr, sysinode->i_entries, + ds.entry_count); + if (query( _("Fix entries for %s inode %"PRIu64" (0x%"PRIx64")? (y/n) "), + dirname, sysinode->i_addr, sysinode->i_addr)) { + sysinode->i_entries = ds.entry_count; bmodified(sysinode->i_bh); log_warn( _("Entries updated\n")); } else { - log_err( _("Entries for inode %llu (0x%llx" - ") left out of sync\n"), - (unsigned long long) - sysinode->i_di.di_num.no_addr, - (unsigned long long) - sysinode->i_di.di_num.no_addr); + log_err(_("Entries for inode %"PRIu64" (0x%"PRIx64") left out of sync\n"), + sysinode->i_addr, sysinode->i_addr); } } error = 0; @@ -2095,20 +2042,20 @@ static int check_system_dir(struct gfs2_inode *sysinode, const char *dirname, */ static inline int is_system_dir(struct gfs2_sbd *sdp, uint64_t block) { - if (block == sdp->md.rooti->i_di.di_num.no_addr) + if (block == sdp->md.rooti->i_addr) return 1; if (sdp->gfs1) return 0; - if (block == sdp->md.jiinode->i_di.di_num.no_addr || - block == sdp->md.pinode->i_di.di_num.no_addr || - block == sdp->master_dir->i_di.di_num.no_addr) + if (block == sdp->md.jiinode->i_addr || + block == sdp->md.pinode->i_addr || + block == sdp->master_dir->i_addr) return 1; return 0; }
static int pass2_check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip) { - uint64_t dirblk = ip->i_di.di_num.no_addr; + uint64_t dirblk = ip->i_addr; struct dir_status ds = {0}; int error;
@@ -2161,7 +2108,11 @@ static int pass2_check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip) (unsigned long long)dirblk, (unsigned long long)dirblk);
if (query( _("Is it okay to add '.' entry? (y/n) "))) { - error = dir_add(ip, ".", 1, &(ip->i_di.di_num), + struct gfs2_inum no = { + .no_addr = ip->i_addr, + .no_formal_ino = ip->i_formal_ino + }; + error = dir_add(ip, ".", 1, &no, (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR)); if (error) { log_err(_("Error adding directory %s: %s\n"), "'.'", @@ -2169,7 +2120,7 @@ static int pass2_check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip) return -errno; } /* directory links to itself via '.' */ - incr_link_count(ip->i_di.di_num, ip, _("". (itself)"")); + incr_link_count(no, ip, _("". (itself)"")); ds.entry_count++; log_err(_("The directory was fixed.\n")); } else { @@ -2177,13 +2128,11 @@ static int pass2_check_dir(struct gfs2_sbd *sdp, struct gfs2_inode *ip) } }
- if (!fsck_abort && ip->i_di.di_entries != ds.entry_count) { - log_err(_("Entries is %d - should be %d for inode block %llu (0x%llx)\n"), - ip->i_di.di_entries, ds.entry_count, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + if (!fsck_abort && ip->i_entries != ds.entry_count) { + log_err(_("Entries is %d - should be %d for inode block %"PRIu64" (0x%"PRIx64")\n"), + ip->i_entries, ds.entry_count, ip->i_addr, ip->i_addr); if (query(_("Fix the entry count? (y/n) "))) { - ip->i_di.di_entries = ds.entry_count; + ip->i_entries = ds.entry_count; bmodified(ip->i_bh); } else { log_err(_("The entry count was not fixed.\n")); @@ -2256,8 +2205,7 @@ int pass2(struct gfs2_sbd *sdp)
/* If we created lost+found, its links should have been properly adjusted, so don't check it. */ - if (lf_was_created && - (dirblk == lf_dip->i_di.di_num.no_addr)) { + if (lf_was_created && (dirblk == lf_dip->i_addr)) { log_debug(_("Pass2 skipping the new lost+found.\n")); continue; } diff --git a/gfs2/fsck/pass3.c b/gfs2/fsck/pass3.c index 4b9c54d8..8b8b19bc 100644 --- a/gfs2/fsck/pass3.c +++ b/gfs2/fsck/pass3.c @@ -25,6 +25,7 @@ static int attach_dotdot_to(struct gfs2_sbd *sdp, uint64_t newdotdot, int filename_len = 2; int err; struct gfs2_inode *ip, *pip; + struct gfs2_inum no;
ip = fsck_load_inode(sdp, block); pip = fsck_load_inode(sdp, newdotdot); @@ -39,14 +40,16 @@ static int attach_dotdot_to(struct gfs2_sbd *sdp, uint64_t newdotdot, log_warn( _("Unable to remove ".." directory entry.\n")); else decr_link_count(olddotdot, block, sdp->gfs1, _("old ".."")); - err = dir_add(ip, filename, filename_len, &pip->i_di.di_num, + no.no_addr = pip->i_addr; + no.no_formal_ino = pip->i_formal_ino; + err = dir_add(ip, filename, filename_len, &no, (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR)); if (err) { log_err(_("Error adding directory %s: %s\n"), filename, strerror(errno)); exit(FSCK_ERROR); } - incr_link_count(pip->i_di.di_num, ip, _("new ".."")); + incr_link_count(no, ip, _("new ".."")); fsck_inode_put(&ip); fsck_inode_put(&pip); return 0; @@ -174,38 +177,38 @@ int pass3(struct gfs2_sbd *sdp) struct gfs2_inode *ip; int q;
- di = dirtree_find(sdp->md.rooti->i_di.di_num.no_addr); + di = dirtree_find(sdp->md.rooti->i_addr); if (di) { log_info( _("Marking root inode connected\n")); di->checked = 1; } if (sdp->gfs1) { - di = dirtree_find(sdp->md.statfs->i_di.di_num.no_addr); + di = dirtree_find(sdp->md.statfs->i_addr); if (di) { log_info( _("Marking GFS1 statfs file inode " "connected\n")); di->checked = 1; } - di = dirtree_find(sdp->md.jiinode->i_di.di_num.no_addr); + di = dirtree_find(sdp->md.jiinode->i_addr); if (di) { log_info( _("Marking GFS1 jindex file inode " "connected\n")); di->checked = 1; } - di = dirtree_find(sdp->md.riinode->i_di.di_num.no_addr); + di = dirtree_find(sdp->md.riinode->i_addr); if (di) { log_info( _("Marking GFS1 rindex file inode " "connected\n")); di->checked = 1; } - di = dirtree_find(sdp->md.qinode->i_di.di_num.no_addr); + di = dirtree_find(sdp->md.qinode->i_addr); if (di) { log_info( _("Marking GFS1 quota file inode " "connected\n")); di->checked = 1; } } else { - di = dirtree_find(sdp->master_dir->i_di.di_num.no_addr); + di = dirtree_find(sdp->master_dir->i_addr); if (di) { log_info( _("Marking master directory inode " "connected\n")); @@ -288,7 +291,7 @@ int pass3(struct gfs2_sbd *sdp) (unsigned long long)di->dinode.no_addr, (unsigned long long)di->dinode.no_addr); /* Don't skip zero size directories with eattrs */ - if (!ip->i_di.di_size && !ip->i_di.di_eattr){ + if (!ip->i_size && !ip->i_eattr){ log_err( _("Unlinked directory has zero " "size.\n")); if (query( _("Remove zero-size unlinked " @@ -320,7 +323,7 @@ int pass3(struct gfs2_sbd *sdp) } if (lf_dip) { log_debug( _("At end of pass3, lost+found entries is %u\n"), - lf_dip->i_di.di_entries); + lf_dip->i_entries); } return FSCK_OK; } diff --git a/gfs2/fsck/pass4.c b/gfs2/fsck/pass4.c index 313ff0fb..42892da1 100644 --- a/gfs2/fsck/pass4.c +++ b/gfs2/fsck/pass4.c @@ -28,18 +28,15 @@ struct metawalk_fxns pass4_fxns_delete = { * link count */ static int fix_link_count(uint32_t counted_links, struct gfs2_inode *ip) { - log_info( _("Fixing inode link count (%d->%d) for %llu (0x%llx) \n"), - ip->i_di.di_nlink, counted_links, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); - if (ip->i_di.di_nlink == counted_links) + log_info(_("Fixing inode link count (%d->%d) for %"PRIu64" (0x%"PRIx64") \n"), + ip->i_nlink, counted_links, ip->i_addr, ip->i_addr); + if (ip->i_nlink == counted_links) return 0; - ip->i_di.di_nlink = counted_links; + ip->i_nlink = counted_links; bmodified(ip->i_bh);
- log_debug( _("Changing inode %llu (0x%llx) to have %u links\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, counted_links); + log_debug(_("Changing inode %"PRIu64" (0x%"PRIx64") to have %u links\n"), + ip->i_addr, ip->i_addr, counted_links); return 0; }
@@ -102,7 +99,7 @@ static int handle_unlinked(struct gfs2_sbd *sdp, uint64_t no_addr,
/* We don't want to clear zero-size files with eattrs - there might be relevent info in them. */ - if (!ip->i_di.di_size && !ip->i_di.di_eattr){ + if (!ip->i_size && !ip->i_eattr){ log_err( _("Unlinked inode has zero size\n")); if (query(_("Clear zero-size unlinked inode? (y/n) "))) { fsck_bitmap_set(ip, no_addr, _("unlinked zero-length"), @@ -164,7 +161,7 @@ static int adjust_lf_links(int lf_addition) if (!lf_addition) return 0;
- if (!(lf_di = dirtree_find(lf_dip->i_di.di_num.no_addr))) { + if (!(lf_di = dirtree_find(lf_dip->i_addr))) { log_crit(_("Unable to find lost+found inode in " "inode_hash!!\n")); return -1; @@ -189,9 +186,9 @@ static int scan_inode_list(struct gfs2_sbd *sdp) ii = (struct inode_info *)tmp; /* Don't check reference counts on the special gfs files */ if (sdp->gfs1 && - ((ii->di_num.no_addr == sdp->md.riinode->i_di.di_num.no_addr) || - (ii->di_num.no_addr == sdp->md.qinode->i_di.di_num.no_addr) || - (ii->di_num.no_addr == sdp->md.statfs->i_di.di_num.no_addr))) + ((ii->di_num.no_addr == sdp->md.riinode->i_addr) || + (ii->di_num.no_addr == sdp->md.qinode->i_addr) || + (ii->di_num.no_addr == sdp->md.statfs->i_addr))) continue; if (ii->counted_links == 0) { if (handle_unlinked(sdp, ii->di_num.no_addr, @@ -225,7 +222,7 @@ static int scan_dir_list(struct gfs2_sbd *sdp) di = (struct dir_info *)tmp; /* Don't check reference counts on the special gfs files */ if (sdp->gfs1 && - di->dinode.no_addr == sdp->md.jiinode->i_di.di_num.no_addr) + di->dinode.no_addr == sdp->md.jiinode->i_addr) continue; if (di->counted_links == 0) { if (handle_unlinked(sdp, di->dinode.no_addr, @@ -282,7 +279,7 @@ int pass4(struct gfs2_sbd *sdp) { if (lf_dip) log_debug( _("At beginning of pass4, lost+found entries is %u\n"), - lf_dip->i_di.di_entries); + lf_dip->i_entries); log_info( _("Checking inode reference counts: multi-links.\n")); if (scan_inode_list(sdp)) { stack; @@ -301,6 +298,6 @@ int pass4(struct gfs2_sbd *sdp)
if (lf_dip) log_debug( _("At end of pass4, lost+found entries is %u\n"), - lf_dip->i_di.di_entries); + lf_dip->i_entries); return FSCK_OK; } diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c index bf1641e8..316be67c 100644 --- a/gfs2/fsck/rgrepair.c +++ b/gfs2/fsck/rgrepair.c @@ -60,10 +60,9 @@ static void find_journaled_rgs(struct gfs2_sbd *sdp) osi_list_init(&false_rgrps.list); for (j = 0; j < sdp->md.journals; j++) { ip = sdp->md.journal[j]; - log_debug(_("Checking for rgrps in journal%d which starts " - "at block 0x%llx.\n"), j, - (unsigned long long)ip->i_di.di_num.no_addr); - jblocks = ip->i_di.di_size / sdp->sd_sb.sb_bsize; + log_debug(_("Checking for rgrps in journal%d which starts at block 0x%"PRIx64".\n"), + j, ip->i_addr); + jblocks = ip->i_size / sdp->sd_sb.sb_bsize; false_count = 0; for (b = 0; b < jblocks; b++) { block_map(ip, b, &new, &dblock, NULL, 0); @@ -876,7 +875,7 @@ static int gfs2_rindex_calculate(struct gfs2_sbd *sdp, int *num_rgs) /* our rindex structures, then something's wrong and we can't trust */ /* the index. */ /* ----------------------------------------------------------------- */ - *num_rgs = sdp->md.riinode->i_di.di_size / sizeof(struct gfs2_rindex); + *num_rgs = sdp->md.riinode->i_size / sizeof(struct gfs2_rindex);
sdp->rgcalc.osi_node = NULL; fix_device_geometry(sdp); @@ -979,7 +978,7 @@ static int expect_rindex_sanity(struct gfs2_sbd *sdp, int *num_rgs) struct osi_node *n, *next = NULL; struct rgrp_tree *rgd, *exp;
- *num_rgs = sdp->md.riinode->i_di.di_size / sizeof(struct gfs2_rindex) ; + *num_rgs = sdp->md.riinode->i_size / sizeof(struct gfs2_rindex) ; for (n = osi_first(&sdp->rgtree); n; n = next) { next = osi_next(n); rgd = (struct rgrp_tree *)n; @@ -1067,7 +1066,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok) /* Read in the rindex */ sdp->rgtree.osi_node = NULL; /* Just to be safe */ rindex_read(sdp, &sdp->rgrps, ok); - if (sdp->md.riinode->i_di.di_size % sizeof(struct gfs2_rindex)) { + if (sdp->md.riinode->i_size % sizeof(struct gfs2_rindex)) { log_warn( _("WARNING: rindex file has an invalid size.\n")); if (!query( _("Truncate the rindex size? (y/n)"))) { log_err(_("The rindex was not repaired.\n")); @@ -1075,11 +1074,10 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok) gfs2_rgrp_free(sdp, &sdp->rgtree); return -1; } - sdp->md.riinode->i_di.di_size /= sizeof(struct gfs2_rindex); - sdp->md.riinode->i_di.di_size *= sizeof(struct gfs2_rindex); + sdp->md.riinode->i_size /= sizeof(struct gfs2_rindex); + sdp->md.riinode->i_size *= sizeof(struct gfs2_rindex); bmodified(sdp->md.riinode->i_bh); - log_err(_("Changing rindex size to %lld.\n"), - (unsigned long long)sdp->md.riinode->i_di.di_size); + log_err(_("Changing rindex size to %"PRIu64".\n"), sdp->md.riinode->i_size); } log_warn( _("L%d: number of rgs expected = %lld.\n"), trust_lvl + 1, (unsigned long long)sdp->rgrps); @@ -1104,8 +1102,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok) /* We cannot grow rindex at this point. Since pass1 has not yet run, we can't allocate blocks. Therefore we must use whatever will fix in the space given. */ - most_that_fit = sdp->md.riinode->i_di.di_size / - sizeof(struct gfs2_rindex); + most_that_fit = sdp->md.riinode->i_size / sizeof(struct gfs2_rindex); log_debug(_("The most we can fit is %d rgrps\n"), most_that_fit); if (most_that_fit < calc_rg_count) @@ -1281,7 +1278,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok) permission. */ if (sdp->md.riinode->i_bh->b_modified) { log_debug("Syncing rindex inode changes to disk.\n"); - gfs2_dinode_out(&sdp->md.riinode->i_di, sdp->md.riinode->i_bh->b_data); + lgfs2_dinode_out(sdp->md.riinode, sdp->md.riinode->i_bh->b_data); bwrite(sdp->md.riinode->i_bh); } return 0; diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c index 26170fa5..84022814 100644 --- a/gfs2/fsck/util.c +++ b/gfs2/fsck/util.c @@ -30,7 +30,7 @@ void big_file_comfort(struct gfs2_inode *ip, uint64_t blks_checked) int i, cs; const char *human_abbrev = " KMGTPE";
- one_percent = ip->i_di.di_blocks / 100; + one_percent = ip->i_blocks / 100; if (blks_checked - last_reported_fblock < one_percent) return;
@@ -41,21 +41,17 @@ void big_file_comfort(struct gfs2_inode *ip, uint64_t blks_checked) if (tv.tv_sec == seconds) return;
- fsize = ip->i_di.di_size; + fsize = ip->i_size; for (i = 0; i < 6 && fsize > 1024; i++) fsize /= 1024; chksize = blks_checked * ip->i_sbd->bsize; for (cs = 0; cs < 6 && chksize > 1024; cs++) chksize /= 1024; seconds = tv.tv_sec; - percent = (blks_checked * 100) / ip->i_di.di_blocks; - log_notice( _("\rChecking %lld%c of %lld%c of file at %lld (0x%llx)" - "- %llu percent complete. \r"), - (long long)chksize, human_abbrev[cs], - (unsigned long long)fsize, human_abbrev[i], - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)percent); + percent = (blks_checked * 100) / ip->i_blocks; + log_notice(_("\rChecking %"PRIu64"%c of %"PRIu64"%c of file at %"PRIu64" (0x%"PRIx64")" + "- %"PRIu64" percent complete. \r"), + chksize, human_abbrev[cs], fsize, human_abbrev[i], ip->i_addr, ip->i_addr, percent); fflush(stdout); }
@@ -281,13 +277,13 @@ struct inode_with_dups *find_dup_ref_inode(struct duptree *dt, osi_list_foreach(ref, &dt->ref_invinode_list) { id = osi_list_entry(ref, struct inode_with_dups, list);
- if (id->block_no == ip->i_di.di_num.no_addr) + if (id->block_no == ip->i_addr) return id; } osi_list_foreach(ref, &dt->ref_inode_list) { id = osi_list_entry(ref, struct inode_with_dups, list);
- if (id->block_no == ip->i_di.di_num.no_addr) + if (id->block_no == ip->i_addr) return id; } return NULL; @@ -365,10 +361,9 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block, "a duplicate within the same inode.\n"), (unsigned long long)block, (unsigned long long)block); - log_info(_("I'll consider the reference from inode %llu " - "(0x%llx) the first reference.\n"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + log_info(_("I'll consider the reference from inode %"PRIu64 + " (0x%"PRIx64") the first reference.\n"), + ip->i_addr, ip->i_addr); dt->dup_flags |= DUPFLAG_REF1_IS_DUPL; dt->refs++; } @@ -393,8 +388,8 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block, log_crit( _("Unable to allocate inode_with_dups structure\n")); return META_ERROR; } - id->block_no = ip->i_di.di_num.no_addr; - q = bitmap_type(ip->i_sbd, ip->i_di.di_num.no_addr); + id->block_no = ip->i_addr; + q = bitmap_type(ip->i_sbd, ip->i_addr); /* If it's an invalid dinode, put it first on the invalid inode reference list otherwise put it on the normal list. */ if (!inode_valid || q == GFS2_BLKST_UNLINKED) @@ -414,13 +409,11 @@ int add_duplicate_ref(struct gfs2_inode *ip, uint64_t block, } id->reftypecount[reftype]++; id->dup_count++; - log_info( _("Found %d reference(s) to block %llu" - " (0x%llx) as %s in %s inode #%llu (0x%llx)\n"), - id->dup_count, (unsigned long long)block, - (unsigned long long)block, reftypes[reftype], + log_info(_("Found %d reference(s) to block %"PRIu64" (0x%"PRIx64") " + "as %s in %s inode #%"PRIu64" (0x%"PRIx64")\n"), + id->dup_count, block, block, reftypes[reftype], inode_valid ? _("valid") : _("invalid"), - (unsigned long long)ip->i_di.di_num.no_addr, - (unsigned long long)ip->i_di.di_num.no_addr); + ip->i_addr, ip->i_addr); if (first) log_info( _("This is the original reference.\n")); else { @@ -587,7 +580,7 @@ uint64_t find_free_blk(struct gfs2_sbd *sdp)
uint64_t *get_dir_hash(struct gfs2_inode *ip) { - unsigned hsize = (1 << ip->i_di.di_depth) * sizeof(uint64_t); + unsigned hsize = (1 << ip->i_depth) * sizeof(uint64_t); int ret; uint64_t *tbl = malloc(hsize);
@@ -620,14 +613,14 @@ void delete_all_dups(struct gfs2_inode *ip)
osi_list_foreach_safe(tmp, &dt->ref_invinode_list, x) { id = osi_list_entry(tmp, struct inode_with_dups, list); - if (id->block_no == ip->i_di.di_num.no_addr) { + if (id->block_no == ip->i_addr) { dup_listent_delete(dt, id); found = 1; } } osi_list_foreach_safe(tmp, &dt->ref_inode_list, x) { id = osi_list_entry(tmp, struct inode_with_dups, list); - if (id->block_no == ip->i_di.di_num.no_addr) { + if (id->block_no == ip->i_addr) { dup_listent_delete(dt, id); found = 1; } diff --git a/gfs2/fsck/util.h b/gfs2/fsck/util.h index d8767247..182868a6 100644 --- a/gfs2/fsck/util.h +++ b/gfs2/fsck/util.h @@ -83,11 +83,11 @@ static const inline char *block_type_string(int q) return blktyp[4]; }
-static inline int is_dir(struct gfs2_dinode *dinode, int gfs1) +static inline int is_dir(struct gfs2_inode *ip, int gfs1) { - if (gfs1 && is_gfs_dir(dinode)) + if (gfs1 && is_gfs_dir(ip)) return 1; - if (S_ISDIR(dinode->di_mode)) + if (S_ISDIR(ip->i_mode)) return 1;
return 0; @@ -95,7 +95,7 @@ static inline int is_dir(struct gfs2_dinode *dinode, int gfs1)
static inline uint32_t gfs_to_gfs2_mode(struct gfs2_inode *ip) { - uint16_t gfs1mode = ip->i_di.__pad1; + uint16_t gfs1mode = ip->i_pad1;
switch (gfs1mode) { case GFS_FILE_DIR: @@ -114,8 +114,8 @@ static inline uint32_t gfs_to_gfs2_mode(struct gfs2_inode *ip) return S_IFSOCK; default: /* This could be an aborted gfs2_convert so look for both. */ - if (ip->i_di.di_entries || - (ip->i_di.di_mode & S_IFMT) == S_IFDIR) + if (ip->i_entries || + (ip->i_mode & S_IFMT) == S_IFDIR) return S_IFDIR; else return S_IFREG; diff --git a/gfs2/glocktop/glocktop.c b/gfs2/glocktop/glocktop.c index 0096a2a5..c0fc0ceb 100644 --- a/gfs2/glocktop/glocktop.c +++ b/gfs2/glocktop/glocktop.c @@ -621,7 +621,7 @@ static const char *show_inode(const char *id, int fd, unsigned long long block) struct gfs2_sbd sbd = { .device_fd = fd, .bsize = bsize };
ip = lgfs2_inode_read(&sbd, block); - if (S_ISDIR(ip->i_di.di_mode)) { + if (S_ISDIR(ip->i_mode)) { struct gfs2_inode *parent; unsigned long long dirarray[256]; int subdepth = 0, error; @@ -635,27 +635,26 @@ static const char *show_inode(const char *id, int fd, unsigned long long block) if (error) break; /* Stop at the root inode */ - if (ip->i_di.di_num.no_addr == - parent->i_di.di_num.no_addr) { + if (ip->i_addr == parent->i_addr) { inode_put(&parent); break; } inode_put(&ip); ip = parent; - dirarray[subdepth++] = parent->i_di.di_num.no_addr; + dirarray[subdepth++] = parent->i_addr; } display_filename(fd, block, dirarray, subdepth); - } else if (S_ISREG(ip->i_di.di_mode)) { + } else if (S_ISREG(ip->i_mode)) { inode_type = "file "; - } else if (S_ISLNK(ip->i_di.di_mode)) { + } else if (S_ISLNK(ip->i_mode)) { inode_type = "link "; - } else if (S_ISCHR(ip->i_di.di_mode)) { + } else if (S_ISCHR(ip->i_mode)) { inode_type = "char device "; - } else if (S_ISBLK(ip->i_di.di_mode)) { + } else if (S_ISBLK(ip->i_mode)) { inode_type = "block device "; - } else if (S_ISFIFO(ip->i_di.di_mode)) { + } else if (S_ISFIFO(ip->i_mode)) { inode_type = "fifo "; - } else if (S_ISSOCK(ip->i_di.di_mode)) { + } else if (S_ISSOCK(ip->i_mode)) { inode_type = "socket "; } else inode_type = "file? "; diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c index 12d845f1..ccb75df3 100644 --- a/gfs2/libgfs2/fs_ops.c +++ b/gfs2/libgfs2/fs_ops.c @@ -27,7 +27,7 @@ static __inline__ uint64_t *metapointer(char *buf, /* Detect directory is a stuffed inode */ static int inode_is_stuffed(const struct gfs2_inode *ip) { - return !ip->i_di.di_height; + return !ip->i_height; }
struct gfs2_inode *lgfs2_inode_get(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh) @@ -38,7 +38,7 @@ struct gfs2_inode *lgfs2_inode_get(struct gfs2_sbd *sdp, struct gfs2_buffer_head if (ip == NULL) { return NULL; } - gfs2_dinode_in(&ip->i_di, bh->b_data); + lgfs2_dinode_in(ip, bh->b_data); ip->i_bh = bh; ip->i_sbd = sdp; return ip; @@ -64,25 +64,25 @@ struct gfs2_inode *is_system_inode(struct gfs2_sbd *sdp, uint64_t block) { int j;
- if (sdp->md.inum && block == sdp->md.inum->i_di.di_num.no_addr) + if (sdp->md.inum && block == sdp->md.inum->i_addr) return sdp->md.inum; - if (sdp->md.statfs && block == sdp->md.statfs->i_di.di_num.no_addr) + if (sdp->md.statfs && block == sdp->md.statfs->i_addr) return sdp->md.statfs; - if (sdp->md.jiinode && block == sdp->md.jiinode->i_di.di_num.no_addr) + if (sdp->md.jiinode && block == sdp->md.jiinode->i_addr) return sdp->md.jiinode; - if (sdp->md.riinode && block == sdp->md.riinode->i_di.di_num.no_addr) + if (sdp->md.riinode && block == sdp->md.riinode->i_addr) return sdp->md.riinode; - if (sdp->md.qinode && block == sdp->md.qinode->i_di.di_num.no_addr) + if (sdp->md.qinode && block == sdp->md.qinode->i_addr) return sdp->md.qinode; - if (sdp->md.pinode && block == sdp->md.pinode->i_di.di_num.no_addr) + if (sdp->md.pinode && block == sdp->md.pinode->i_addr) return sdp->md.pinode; - if (sdp->md.rooti && block == sdp->md.rooti->i_di.di_num.no_addr) + if (sdp->md.rooti && block == sdp->md.rooti->i_addr) return sdp->md.rooti; - if (sdp->master_dir && block == sdp->master_dir->i_di.di_num.no_addr) + if (sdp->master_dir && block == sdp->master_dir->i_addr) return sdp->master_dir; for (j = 0; j < sdp->md.journals; j++) if (sdp->md.journal && sdp->md.journal[j] && - block == sdp->md.journal[j]->i_di.di_num.no_addr) + block == sdp->md.journal[j]->i_addr) return sdp->md.journal[j]; return NULL; } @@ -90,11 +90,11 @@ struct gfs2_inode *is_system_inode(struct gfs2_sbd *sdp, uint64_t block) void inode_put(struct gfs2_inode **ip_in) { struct gfs2_inode *ip = *ip_in; - uint64_t block = ip->i_di.di_num.no_addr; + uint64_t block = ip->i_addr; struct gfs2_sbd *sdp = ip->i_sbd;
if (ip->i_bh->b_modified) { - gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data); + lgfs2_dinode_out(ip, ip->i_bh->b_data); if (!ip->bh_owned && is_system_inode(sdp, block)) fprintf(stderr, "Warning: Change made to inode " "were discarded.\n"); @@ -212,7 +212,7 @@ int lgfs2_meta_alloc(struct gfs2_inode *ip, uint64_t *blkno) ip->i_sbd->gfs1 ? GFS2_BLKST_DINODE : GFS2_BLKST_USED, blkno, 0); if (ret == 0) { - ip->i_di.di_goal_meta = *blkno; + ip->i_goal_meta = *blkno; bmodified(ip->i_bh); } return ret; @@ -242,9 +242,9 @@ void unstuff_dinode(struct gfs2_inode *ip) struct gfs2_sbd *sdp = ip->i_sbd; struct gfs2_buffer_head *bh; uint64_t block = 0; - int isdir = S_ISDIR(ip->i_di.di_mode) || is_gfs_dir(&ip->i_di); + int isdir = S_ISDIR(ip->i_mode) || is_gfs_dir(ip);
- if (ip->i_di.di_size) { + if (ip->i_size) { if (lgfs2_meta_alloc(ip, &block)) exit(1); if (isdir) { @@ -273,13 +273,13 @@ void unstuff_dinode(struct gfs2_inode *ip)
buffer_clear_tail(sdp, ip->i_bh, sizeof(struct gfs2_dinode));
- if (ip->i_di.di_size) { + if (ip->i_size) { *(uint64_t *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode)) = cpu_to_be64(block); /* no need: bmodified(ip->i_bh); buffer_clear_tail does it */ - ip->i_di.di_blocks++; + ip->i_blocks++; }
- ip->i_di.di_height = 1; + ip->i_height = 1; }
/** @@ -305,7 +305,7 @@ uint64_t lgfs2_space_for_data(const struct gfs2_sbd *sdp, const unsigned bsize, * rg: The resource group in which to allocate the extent * di_size: The size of the file in bytes * ip: A pointer to the inode structure, whose fields will be set appropriately. - * If ip->i_di.di_num.no_addr is not 0, the extent search will be skipped and + * If ip->i_num.no_addr is not 0, the extent search will be skipped and * the file allocated from that address. * flags: GFS2_DIF_* flags * mode: File mode flags, see creat(2) @@ -316,13 +316,12 @@ uint64_t lgfs2_space_for_data(const struct gfs2_sbd *sdp, const unsigned bsize, int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct gfs2_inode *ip, uint32_t flags, unsigned mode) { unsigned extlen; - struct gfs2_dinode *di = &ip->i_di; struct gfs2_sbd *sdp = rg->rgrps->sdp; struct lgfs2_rbm rbm = { .rgd = rg, .offset = 0, .bii = 0 }; uint32_t blocks = lgfs2_space_for_data(sdp, sdp->bsize, di_size);
- if (ip->i_di.di_num.no_addr != 0) { - if (lgfs2_rbm_from_block(&rbm, ip->i_di.di_num.no_addr) != 0) + if (ip->i_addr != 0) { + if (lgfs2_rbm_from_block(&rbm, ip->i_addr) != 0) return 1; } else if (lgfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &blocks) != 0) { return 1; @@ -336,20 +335,20 @@ int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct gfs2_inode *ip, u
ip->i_sbd = sdp;
- di->di_header.mh_magic = GFS2_MAGIC; - di->di_header.mh_type = GFS2_METATYPE_DI; - di->di_header.mh_format = GFS2_FORMAT_DI; - di->di_size = di_size; - di->di_num.no_addr = lgfs2_rbm_to_block(&rbm); - di->di_num.no_formal_ino = sdp->md.next_inum++; - di->di_mode = mode; - di->di_nlink = 1; - di->di_blocks = blocks; - di->di_atime = di->di_mtime = di->di_ctime = sdp->time; - di->di_goal_data = di->di_num.no_addr + di->di_blocks - 1; - di->di_goal_meta = di->di_goal_data - ((di_size + sdp->bsize - 1) / sdp->bsize); - di->di_height = calc_tree_height(ip, di_size); - di->di_flags = flags; + ip->i_magic = GFS2_MAGIC; + ip->i_type = GFS2_METATYPE_DI; + ip->i_format = GFS2_FORMAT_DI; + ip->i_size = di_size; + ip->i_addr = lgfs2_rbm_to_block(&rbm); + ip->i_formal_ino = sdp->md.next_inum++; + ip->i_mode = mode; + ip->i_nlink = 1; + ip->i_blocks = blocks; + ip->i_atime = ip->i_mtime = ip->i_ctime = sdp->time; + ip->i_goal_data = ip->i_addr + ip->i_blocks - 1; + ip->i_goal_meta = ip->i_goal_data - ((di_size + sdp->bsize - 1) / sdp->bsize); + ip->i_height = calc_tree_height(ip, di_size); + ip->i_flags = flags;
rg->rg.rg_free -= blocks; rg->rg.rg_dinodes += 1; @@ -366,10 +365,10 @@ unsigned int calc_tree_height(struct gfs2_inode *ip, uint64_t size) uint64_t *arr; unsigned int max, height;
- if (ip->i_di.di_size > size) - size = ip->i_di.di_size; + if (ip->i_size > size) + size = ip->i_size;
- if (S_ISDIR(ip->i_di.di_mode)) { + if (S_ISDIR(ip->i_mode)) { arr = sdp->sd_jheightsize; max = sdp->sd_max_jheight; } else { @@ -392,7 +391,7 @@ void build_height(struct gfs2_inode *ip, int height) unsigned int x; int new_block;
- while (ip->i_di.di_height < height) { + while (ip->i_height < height) { new_block = 0; bp = (uint64_t *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode)); for (x = 0; x < sdp->sd_diptrs; x++, bp++) @@ -423,17 +422,17 @@ void build_height(struct gfs2_inode *ip, int height) if (new_block) { *(uint64_t *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode)) = cpu_to_be64(block); /* no need: bmodified(ip->i_bh);*/ - ip->i_di.di_blocks++; + ip->i_blocks++; }
- ip->i_di.di_height++; + ip->i_height++; } }
void find_metapath(struct gfs2_inode *ip, uint64_t block, struct metapath *mp) { const uint32_t inptrs = ip->i_sbd->sd_inptrs; - unsigned int i = ip->i_di.di_height; + unsigned int i = ip->i_height;
memset(mp, 0, sizeof(struct metapath)); while (i--) { @@ -462,7 +461,7 @@ void lookup_block(struct gfs2_inode *ip, struct gfs2_buffer_head *bh, return; *ptr = cpu_to_be64(*block); bmodified(bh); - ip->i_di.di_blocks++; + ip->i_blocks++; bmodified(ip->i_bh);
*new = 1; @@ -487,17 +486,17 @@ void block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
if (inode_is_stuffed(ip)) { if (!lblock) { - *dblock = ip->i_di.di_num.no_addr; + *dblock = ip->i_addr; if (extlen) *extlen = 1; } return; }
- bsize = (S_ISDIR(ip->i_di.di_mode)) ? sdp->sd_jbsize : sdp->bsize; + bsize = (S_ISDIR(ip->i_mode)) ? sdp->sd_jbsize : sdp->bsize;
height = calc_tree_height(ip, (lblock + 1) * bsize); - if (ip->i_di.di_height < height) { + if (ip->i_height < height) { if (!create) return;
@@ -505,7 +504,7 @@ void block_map(struct gfs2_inode *ip, uint64_t lblock, int *new, }
find_metapath(ip, lblock, &mp); - end_of_metadata = ip->i_di.di_height - 1; + end_of_metadata = ip->i_height - 1;
bh = ip->i_bh;
@@ -525,7 +524,7 @@ void block_map(struct gfs2_inode *ip, uint64_t lblock, int *new, gfs2_meta_header_out(&mh, bh->b_data); bmodified(bh); } else { - if (*dblock == ip->i_di.di_num.no_addr) + if (*dblock == ip->i_addr) bh = ip->i_bh; else bh = bread(sdp, *dblock); @@ -585,15 +584,15 @@ int gfs2_readi(struct gfs2_inode *ip, void *buf, uint32_t extlen = 0; unsigned int amount; int not_new = 0; - int isdir = !!(S_ISDIR(ip->i_di.di_mode)); - int journaled = ip->i_di.di_flags & GFS2_DIF_JDATA; + int isdir = !!(S_ISDIR(ip->i_mode)); + int journaled = ip->i_flags & GFS2_DIF_JDATA; int copied = 0;
- if (offset >= ip->i_di.di_size) + if (offset >= ip->i_size) return 0;
- if ((offset + size) > ip->i_di.di_size) - size = ip->i_di.di_size - offset; + if ((offset + size) > ip->i_size) + size = ip->i_size - offset;
if (!size) return 0; @@ -627,7 +626,7 @@ int gfs2_readi(struct gfs2_inode *ip, void *buf, }
if (dblock) { - if (dblock == ip->i_di.di_num.no_addr) + if (dblock == ip->i_addr) bh = ip->i_bh; else bh = bread(sdp, dblock); @@ -672,7 +671,7 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf, uint32_t extlen = 0; unsigned int amount; int new; - int isdir = !!(S_ISDIR(ip->i_di.di_mode)); + int isdir = !!(S_ISDIR(ip->i_mode)); const uint64_t start = offset; int copied = 0;
@@ -718,7 +717,7 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf, bmodified(bh); } } else { - if (dblock == ip->i_di.di_num.no_addr) + if (dblock == ip->i_addr) bh = ip->i_bh; else bh = bread(sdp, dblock); @@ -735,9 +734,9 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf, o = (isdir) ? sizeof(struct gfs2_meta_header) : 0; }
- if (resize && ip->i_di.di_size < start + copied) { + if (resize && ip->i_size < start + copied) { bmodified(ip->i_bh); - ip->i_di.di_size = start + copied; + ip->i_size = start + copied; }
return copied; @@ -804,7 +803,7 @@ static int dirent_alloc(struct gfs2_inode *dip, struct gfs2_buffer_head *bh, dent->de_name_len = cpu_to_be16(name_len); bmodified(bh); *dent_out = dent; - dip->i_di.di_entries++; + dip->i_entries++; bmodified(dip->i_bh); return 0; } @@ -834,7 +833,7 @@ static int dirent_alloc(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,
*dent_out = new; bmodified(bh); - dip->i_di.di_entries++; + dip->i_entries++; bmodified(dip->i_bh); return 0; } @@ -843,7 +842,7 @@ static int dirent_alloc(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,
*dent_out = dent; bmodified(bh); - dip->i_di.di_entries++; + dip->i_entries++; bmodified(dip->i_bh); return 0; } @@ -866,9 +865,9 @@ void dirent2_del(struct gfs2_inode *dip, struct gfs2_buffer_head *bh, lf->lf_entries = cpu_to_be16(lf->lf_entries); }
- if (dip->i_di.di_entries) { + if (dip->i_entries) { bmodified(dip->i_bh); - dip->i_di.di_entries--; + dip->i_entries--; } if (!prev) { cur->de_inum.no_addr = 0; @@ -925,7 +924,7 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
oleaf = (struct gfs2_leaf *)obh->b_data;
- len = 1 << (dip->i_di.di_depth - be16_to_cpu(oleaf->lf_depth)); + len = 1 << (dip->i_depth - be16_to_cpu(oleaf->lf_depth)); half_len = len >> 1;
lp = calloc(1, half_len * sizeof(uint64_t)); @@ -949,7 +948,7 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
free(lp);
- divider = (start + half_len) << (32 - dip->i_di.di_depth); + divider = (start + half_len) << (32 - dip->i_depth);
gfs2_dirent_first(dip, obh, &dent);
@@ -994,15 +993,15 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no, } new->de_inum.no_formal_ino = 0; /* Don't count the sentinel dirent as an entry */ - dip->i_di.di_entries--; + dip->i_entries--; }
oleaf->lf_depth = be16_to_cpu(oleaf->lf_depth) + 1; oleaf->lf_depth = cpu_to_be16(oleaf->lf_depth); nleaf->lf_depth = oleaf->lf_depth;
- nleaf->lf_inode = cpu_to_be64(dip->i_di.di_num.no_addr); - dip->i_di.di_blocks++; + nleaf->lf_inode = cpu_to_be64(dip->i_addr); + dip->i_blocks++; bmodified(dip->i_bh);
bmodified(obh); /* Need to do this in case nothing was moved */ @@ -1025,7 +1024,7 @@ static void dir_double_exhash(struct gfs2_inode *dip) exit(-1); }
- for (block = dip->i_di.di_size >> sdp->sd_hash_bsize_shift; block--;) { + for (block = dip->i_size >> sdp->sd_hash_bsize_shift; block--;) { count = gfs2_readi(dip, (char *)buf, block * sdp->sd_hash_bsize, sdp->sd_hash_bsize); @@ -1058,7 +1057,7 @@ static void dir_double_exhash(struct gfs2_inode *dip)
free(buf);
- dip->i_di.di_depth++; + dip->i_depth++; bmodified(dip->i_bh); }
@@ -1151,8 +1150,8 @@ static int dir_e_add(struct gfs2_inode *dip, const char *filename, int len, hash = gfs2_disk_hash(filename, len); restart: /* Have to kludge because (hash >> 32) gives hash for some reason. */ - if (dip->i_di.di_depth) - lindex = hash >> (32 - dip->i_di.di_depth); + if (dip->i_depth) + lindex = hash >> (32 - dip->i_depth); else lindex = 0;
@@ -1166,15 +1165,15 @@ restart:
if (dirent_alloc(dip, bh, len, &dent)) {
- if (be16_to_cpu(leaf->lf_depth) < dip->i_di.di_depth) { - llen = 1 << (dip->i_di.di_depth - + if (be16_to_cpu(leaf->lf_depth) < dip->i_depth) { + llen = 1 << (dip->i_depth - be16_to_cpu(leaf->lf_depth)); dir_split_leaf(dip, lindex & ~(llen - 1), leaf_no, bh); brelse(bh); goto restart;
- } else if (dip->i_di.di_depth < GFS2_DIR_MAX_DEPTH) { + } else if (dip->i_depth < GFS2_DIR_MAX_DEPTH) { brelse(bh); dir_double_exhash(dip); goto restart; @@ -1201,11 +1200,11 @@ restart: nleaf = (struct gfs2_leaf *)nbh->b_data; nleaf->lf_depth = leaf->lf_depth; nleaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE); - nleaf->lf_inode = cpu_to_be64(dip->i_di.di_num.no_addr); + nleaf->lf_inode = cpu_to_be64(dip->i_addr); err = dirent_alloc(dip, nbh, len, &dent); if (err) return err; - dip->i_di.di_blocks++; + dip->i_blocks++; bmodified(dip->i_bh); bmodified(bh); brelse(bh); @@ -1252,8 +1251,8 @@ static void dir_make_exhash(struct gfs2_inode *dip)
leaf = (struct gfs2_leaf *)bh->b_data; leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE); - leaf->lf_entries = cpu_to_be16(dip->i_di.di_entries); - leaf->lf_inode = cpu_to_be64(dip->i_di.di_num.no_addr); + leaf->lf_entries = cpu_to_be16(dip->i_entries); + leaf->lf_inode = cpu_to_be64(dip->i_addr); buffer_copy_tail(sdp, bh, sizeof(struct gfs2_leaf), dip->i_bh, sizeof(struct gfs2_dinode));
@@ -1263,7 +1262,7 @@ static void dir_make_exhash(struct gfs2_inode *dip) do { if (!dent->de_inum.no_formal_ino) continue; - if (++x == dip->i_di.di_entries) + if (++x == dip->i_entries) break; } while (gfs2_dirent_next(dip, bh, &dent) == 0);
@@ -1281,16 +1280,16 @@ static void dir_make_exhash(struct gfs2_inode *dip) for (x = sdp->sd_hash_ptrs; x--; lp++) *lp = cpu_to_be64(bn);
- dip->i_di.di_size = sdp->bsize / 2; - dip->i_di.di_blocks++; - dip->i_di.di_flags |= GFS2_DIF_EXHASH; - dip->i_di.di_payload_format = 0; + dip->i_size = sdp->bsize / 2; + dip->i_blocks++; + dip->i_flags |= GFS2_DIF_EXHASH; + dip->i_payload_format = 0; /* no need: bmodified(dip->i_bh); buffer_clear_tail does it. */
for (x = sdp->sd_hash_ptrs, y = -1; x; x >>= 1, y++) ; - dip->i_di.di_depth = y; + dip->i_depth = y;
- gfs2_dinode_out(&dip->i_di, dip->i_bh->b_data); + lgfs2_dinode_out(dip, dip->i_bh->b_data); bwrite(dip->i_bh); }
@@ -1319,7 +1318,7 @@ int dir_add(struct gfs2_inode *dip, const char *filename, int len, struct gfs2_inum *inum, unsigned int type) { int err = 0; - if (dip->i_di.di_flags & GFS2_DIF_EXHASH) + if (dip->i_flags & GFS2_DIF_EXHASH) err = dir_e_add(dip, filename, len, inum, type); else err = dir_l_add(dip, filename, len, inum, type); @@ -1433,15 +1432,15 @@ int lgfs2_write_filemeta(struct gfs2_inode *ip) unsigned height = 0; struct metapath mp; struct gfs2_sbd *sdp = ip->i_sbd; - uint64_t dblocks = (ip->i_di.di_size + sdp->bsize - 1) / sdp->bsize; - uint64_t ptr0 = ip->i_di.di_num.no_addr + 1; + uint64_t dblocks = (ip->i_size + sdp->bsize - 1) / sdp->bsize; + uint64_t ptr0 = ip->i_addr + 1; unsigned ptrs = 1; struct gfs2_meta_header mh = { .mh_magic = GFS2_MAGIC, .mh_type = GFS2_METATYPE_IN, .mh_format = GFS2_FORMAT_IN, }; - struct gfs2_buffer_head *bh = bget(sdp, ip->i_di.di_num.no_addr); + struct gfs2_buffer_head *bh = bget(sdp, ip->i_addr); if (bh == NULL) return 1;
@@ -1450,7 +1449,7 @@ int lgfs2_write_filemeta(struct gfs2_inode *ip) height. Just need to add 1 to convert ptr index to quantity later. */ find_metapath(ip, dblocks - 1, &mp);
- for (height = 0; height < ip->i_di.di_height; height++) { + for (height = 0; height < ip->i_height; height++) { unsigned p; /* The number of pointers in this height will be the number of full indirect blocks pointed to by the previous height @@ -1462,7 +1461,7 @@ int lgfs2_write_filemeta(struct gfs2_inode *ip) char *start = bh->b_data; if (height == 0) { start += sizeof(struct gfs2_dinode); - gfs2_dinode_out(&ip->i_di, bh->b_data); + lgfs2_dinode_out(ip, bh->b_data); } else { start += sizeof(struct gfs2_meta_header); gfs2_meta_header_out(&mh, bh->b_data); @@ -1493,6 +1492,10 @@ static struct gfs2_inode *__createi(struct gfs2_inode *dip,
gfs2_lookupi(dip, filename, strlen(filename), &ip); if (!ip) { + struct gfs2_inum parent = { + .no_formal_ino = dip->i_formal_ino, + .no_addr = dip->i_addr, + }; err = lgfs2_dinode_alloc(sdp, 1, &bn); if (err != 0) return NULL; @@ -1513,10 +1516,10 @@ static struct gfs2_inode *__createi(struct gfs2_inode *dip, is_dir = S_ISDIR(mode); if (is_dir) { bmodified(dip->i_bh); - dip->i_di.di_nlink++; + dip->i_nlink++; }
- err = __init_dinode(sdp, &bh, &inum, mode, flags, &dip->i_di.di_num, if_gfs1); + err = __init_dinode(sdp, &bh, &inum, mode, flags, &parent, if_gfs1); if (err != 0) return NULL;
@@ -1586,7 +1589,7 @@ static int leaf_search(struct gfs2_inode *dip, struct gfs2_buffer_head *bh, struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data; entries = be16_to_cpu(leaf->lf_entries); } else if (type == IS_DINODE) - entries = dip->i_di.di_entries; + entries = dip->i_entries; else return -1;
@@ -1636,14 +1639,14 @@ static int linked_leaf_search(struct gfs2_inode *dip, const char *filename, uint32_t hash; int error = 0;
- hsize = 1 << dip->i_di.di_depth; - if(hsize * sizeof(uint64_t) != dip->i_di.di_size) + hsize = 1 << dip->i_depth; + if(hsize * sizeof(uint64_t) != dip->i_size) return -1;
/* Figure out the address of the leaf node. */
hash = gfs2_disk_hash(filename, len); - lindex = hash >> (32 - dip->i_di.di_depth); + lindex = hash >> (32 - dip->i_depth);
error = get_first_leaf(dip, lindex, &bh_next); if (error) @@ -1755,10 +1758,10 @@ int dir_search(struct gfs2_inode *dip, const char *filename, int len, { int error;
- if(!S_ISDIR(dip->i_di.di_mode) && !is_gfs_dir(&dip->i_di)) + if(!S_ISDIR(dip->i_mode) && !is_gfs_dir(dip)) return -1;
- if (dip->i_di.di_flags & GFS2_DIF_EXHASH) + if (dip->i_flags & GFS2_DIF_EXHASH) error = dir_e_search(dip, filename, len, type, inum); else error = dir_l_search(dip, filename, len, type, inum); @@ -1775,7 +1778,7 @@ static int dir_e_del(struct gfs2_inode *dip, const char *filename, int len) struct gfs2_buffer_head *bh = NULL; struct gfs2_dirent *cur, *prev;
- lindex = (1 << (dip->i_di.di_depth))-1; + lindex = (1 << (dip->i_depth))-1;
for(; (lindex >= 0) && !found; lindex--){ error = lgfs2_get_leaf_ptr(dip, lindex, &leaf_no); @@ -1843,10 +1846,10 @@ int gfs2_dirent_del(struct gfs2_inode *dip, const char *filename, int len) { int error;
- if(!S_ISDIR(dip->i_di.di_mode) && !is_gfs_dir(&dip->i_di)) + if(!S_ISDIR(dip->i_mode) && !is_gfs_dir(dip)) return -1;
- if (dip->i_di.di_flags & GFS2_DIF_EXHASH) + if (dip->i_flags & GFS2_DIF_EXHASH) error = dir_e_del(dip, filename, len); else error = dir_l_del(dip, filename, len); @@ -1929,7 +1932,7 @@ int gfs2_freedi(struct gfs2_sbd *sdp, uint64_t diblock) ip = lgfs2_inode_get(sdp, bh); if (ip == NULL) return -1; - height = ip->i_di.di_height; + height = ip->i_height; osi_list_add(&bh->b_altlist, &metalist[0]);
for (h = 0; h < height; h++){ diff --git a/gfs2/libgfs2/gfs1.c b/gfs2/libgfs2/gfs1.c index b2294a8b..6f74ce4d 100644 --- a/gfs2/libgfs2/gfs1.c +++ b/gfs2/libgfs2/gfs1.c @@ -19,7 +19,7 @@
static __inline__ int fs_is_jdata(struct gfs2_inode *ip) { - return ip->i_di.di_flags & GFS2_DIF_JDATA; + return ip->i_flags & GFS2_DIF_JDATA; }
static __inline__ uint64_t * @@ -31,9 +31,9 @@ gfs1_metapointer(char *buf, unsigned int height, struct metapath *mp) return ((uint64_t *)(buf + head_size)) + mp->mp_list[height]; }
-int is_gfs_dir(struct gfs2_dinode *dinode) +int is_gfs_dir(struct gfs2_inode *ip) { - if (dinode->__pad1 == GFS_FILE_DIR) + if (ip->i_pad1 == GFS_FILE_DIR) return 1; return 0; } @@ -61,7 +61,7 @@ void gfs1_lookup_block(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,
*ptr = cpu_to_be64(*block); bmodified(bh); - ip->i_di.di_blocks++; + ip->i_blocks++; bmodified(ip->i_bh);
*new = 1; @@ -84,9 +84,9 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new, if (extlen) *extlen = 0;
- if (!ip->i_di.di_height) { /* stuffed */ + if (!ip->i_height) { /* stuffed */ if (!lblock) { - *dblock = ip->i_di.di_num.no_addr; + *dblock = ip->i_addr; if (extlen) *extlen = 1; } @@ -96,7 +96,7 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new, bsize = (fs_is_jdata(ip)) ? sdp->sd_jbsize : sdp->bsize;
height = calc_tree_height(ip, (lblock + 1) * bsize); - if (ip->i_di.di_height < height) { + if (ip->i_height < height) { if (!create) return;
@@ -104,7 +104,7 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new, }
find_metapath(ip, lblock, &mp); - end_of_metadata = ip->i_di.di_height - 1; + end_of_metadata = ip->i_height - 1;
bh = ip->i_bh;
@@ -125,7 +125,7 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new, gfs2_meta_header_out(&mh, bh->b_data); bmodified(bh); } else { - if (*dblock == ip->i_di.di_num.no_addr) + if (*dblock == ip->i_addr) bh = ip->i_bh; else bh = bread(sdp, *dblock); @@ -179,7 +179,7 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset, if (!size) return 0;
- if (!ip->i_di.di_height && /* stuffed */ + if (!ip->i_height && /* stuffed */ ((start + size) > (sdp->bsize - sizeof(struct gfs_dinode)))) unstuff_dinode(ip);
@@ -191,7 +191,7 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset, offset &= sdp->bsize - 1; }
- if (!ip->i_di.di_height) /* stuffed */ + if (!ip->i_height) /* stuffed */ offset += sizeof(struct gfs_dinode); else if (journaled) offset += sizeof(struct gfs2_meta_header); @@ -208,12 +208,12 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset, return -1; }
- if (dblock == ip->i_di.di_num.no_addr) + if (dblock == ip->i_addr) bh = ip->i_bh; else bh = bread(sdp, dblock);
- if (journaled && dblock != ip->i_di.di_num.no_addr ) { + if (journaled && dblock != ip->i_addr ) { struct gfs2_meta_header mh;
mh.mh_magic = GFS2_MAGIC; @@ -235,86 +235,58 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset, offset = (journaled) ? sizeof(struct gfs2_meta_header) : 0; }
- if (ip->i_di.di_size < start + copied) { + if (ip->i_size < start + copied) { bmodified(ip->i_bh); - ip->i_di.di_size = start + copied; + ip->i_size = start + copied; } - ip->i_di.di_mtime = ip->i_di.di_ctime = time(NULL); - gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data); + ip->i_mtime = ip->i_ctime = time(NULL); + lgfs2_dinode_out(ip, ip->i_bh->b_data); bmodified(ip->i_bh); return copied; }
-static void gfs_dinode_in(struct gfs_dinode *di, char *buf) +static struct gfs2_inode *__gfs_inode_get(struct gfs2_sbd *sdp, char *buf) { - struct gfs_dinode *str = (struct gfs_dinode *)buf; - - gfs2_meta_header_in(&di->di_header, buf); - gfs2_inum_in(&di->di_num, (char *)&str->di_num); - - di->di_mode = be32_to_cpu(str->di_mode); - di->di_uid = be32_to_cpu(str->di_uid); - di->di_gid = be32_to_cpu(str->di_gid); - di->di_nlink = be32_to_cpu(str->di_nlink); - di->di_size = be64_to_cpu(str->di_size); - di->di_blocks = be64_to_cpu(str->di_blocks); - di->di_atime = be64_to_cpu(str->di_atime); - di->di_mtime = be64_to_cpu(str->di_mtime); - di->di_ctime = be64_to_cpu(str->di_ctime); - di->di_major = be32_to_cpu(str->di_major); - di->di_minor = be32_to_cpu(str->di_minor); - di->di_goal_dblk = be64_to_cpu(str->di_goal_dblk); - di->di_goal_mblk = be64_to_cpu(str->di_goal_mblk); - di->di_flags = be32_to_cpu(str->di_flags); - di->di_payload_format = be32_to_cpu(str->di_payload_format); - di->di_type = be16_to_cpu(str->di_type); - di->di_height = be16_to_cpu(str->di_height); - di->di_depth = be16_to_cpu(str->di_depth); - di->di_entries = be32_to_cpu(str->di_entries); - di->di_eattr = be64_to_cpu(str->di_eattr); -} - -static struct gfs2_inode *__gfs_inode_get(struct gfs2_sbd *sdp, char *buf, uint64_t di_addr) -{ - struct gfs_dinode gfs1_dinode; + struct gfs_dinode *di; struct gfs2_inode *ip;
ip = calloc(1, sizeof(struct gfs2_inode)); if (ip == NULL) { return NULL; } - gfs_dinode_in(&gfs1_dinode, buf); - memcpy(&ip->i_di.di_header, &gfs1_dinode.di_header, - sizeof(struct gfs2_meta_header)); - memcpy(&ip->i_di.di_num, &gfs1_dinode.di_num, - sizeof(struct gfs2_inum)); - ip->i_di.di_mode = gfs1_dinode.di_mode; - ip->i_di.di_uid = gfs1_dinode.di_uid; - ip->i_di.di_gid = gfs1_dinode.di_gid; - ip->i_di.di_nlink = gfs1_dinode.di_nlink; - ip->i_di.di_size = gfs1_dinode.di_size; - ip->i_di.di_blocks = gfs1_dinode.di_blocks; - ip->i_di.di_atime = gfs1_dinode.di_atime; - ip->i_di.di_mtime = gfs1_dinode.di_mtime; - ip->i_di.di_ctime = gfs1_dinode.di_ctime; - ip->i_di.di_major = gfs1_dinode.di_major; - ip->i_di.di_minor = gfs1_dinode.di_minor; - ip->i_di.di_goal_data = gfs1_dinode.di_goal_dblk; - ip->i_di.di_goal_meta = gfs1_dinode.di_goal_mblk; - ip->i_di.di_flags = gfs1_dinode.di_flags; - ip->i_di.di_payload_format = gfs1_dinode.di_payload_format; - ip->i_di.__pad1 = gfs1_dinode.di_type; - ip->i_di.di_height = gfs1_dinode.di_height; - ip->i_di.di_depth = gfs1_dinode.di_depth; - ip->i_di.di_entries = gfs1_dinode.di_entries; - ip->i_di.di_eattr = gfs1_dinode.di_eattr; + di = (struct gfs_dinode *)buf; + ip->i_magic = be32_to_cpu(di->di_header.mh_magic); + ip->i_type = be32_to_cpu(di->di_header.mh_type); + ip->i_format = be32_to_cpu(di->di_header.mh_format); + ip->i_formal_ino = be64_to_cpu(di->di_num.no_formal_ino); + ip->i_addr = be64_to_cpu(di->di_num.no_addr); + ip->i_mode = be32_to_cpu(di->di_mode); + ip->i_uid = be32_to_cpu(di->di_uid); + ip->i_gid = be32_to_cpu(di->di_gid); + ip->i_nlink = be32_to_cpu(di->di_nlink); + ip->i_size = be64_to_cpu(di->di_size); + ip->i_blocks = be64_to_cpu(di->di_blocks); + ip->i_atime = be64_to_cpu(di->di_atime); + ip->i_mtime = be64_to_cpu(di->di_mtime); + ip->i_ctime = be64_to_cpu(di->di_ctime); + ip->i_major = be32_to_cpu(di->di_major); + ip->i_minor = be32_to_cpu(di->di_minor); + ip->i_goal_data = (uint64_t)be32_to_cpu(di->di_goal_dblk); + ip->i_goal_meta = (uint64_t)be32_to_cpu(di->di_goal_mblk); + ip->i_flags = be32_to_cpu(di->di_flags); + ip->i_payload_format = be32_to_cpu(di->di_payload_format); + ip->i_pad1 = be16_to_cpu(di->di_type); + ip->i_height = be16_to_cpu(di->di_height); + ip->i_depth = be16_to_cpu(di->di_depth); + ip->i_entries = be32_to_cpu(di->di_entries); + ip->i_eattr = be64_to_cpu(di->di_eattr); ip->i_sbd = sdp; return ip; }
struct gfs2_inode *lgfs2_gfs_inode_get(struct gfs2_sbd *sdp, char *buf) { - return __gfs_inode_get(sdp, buf, 0); + return __gfs_inode_get(sdp, buf); }
struct gfs2_inode *lgfs2_gfs_inode_read(struct gfs2_sbd *sdp, uint64_t di_addr) @@ -329,7 +301,7 @@ struct gfs2_inode *lgfs2_gfs_inode_read(struct gfs2_sbd *sdp, uint64_t di_addr) brelse(bh); return NULL; } - ip = __gfs_inode_get(sdp, bh->b_data, di_addr); + ip = __gfs_inode_get(sdp, bh->b_data); ip->i_bh = bh; ip->bh_owned = 1; return ip; diff --git a/gfs2/libgfs2/lang.c b/gfs2/libgfs2/lang.c index 3faa5abd..da35b990 100644 --- a/gfs2/libgfs2/lang.c +++ b/gfs2/libgfs2/lang.c @@ -162,7 +162,7 @@ static uint64_t ast_lookup_path(char *path, struct gfs2_sbd *sbd)
while (ip != NULL) { if (segment == NULL) { // No more segments - bn = ip->i_di.di_num.no_addr; + bn = ip->i_addr; inode_put(&ip); return bn; } @@ -221,7 +221,7 @@ static uint64_t ast_lookup_id(const char *id, struct gfs2_sbd *sbd) bn = sbd->sd_sb.sb_root_dir.no_addr; break; case ID_RINDEX: - bn = sbd->md.riinode->i_di.di_num.no_addr; + bn = sbd->md.riinode->i_addr; break; default: return 0; diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h index feace819..cefb60c8 100644 --- a/gfs2/libgfs2/libgfs2.h +++ b/gfs2/libgfs2/libgfs2.h @@ -221,11 +221,45 @@ struct gfs2_buffer_head { };
struct gfs2_inode { - struct gfs2_dinode i_di; struct gfs2_buffer_head *i_bh; struct gfs2_sbd *i_sbd; struct rgrp_tree *i_rgd; /* performance hint */ int bh_owned; /* Is this bh owned, iow, should we release it later? */ + + /* Native-endian versions of the dinode fields */ + uint32_t i_magic; + uint32_t i_type; + uint32_t i_format; + uint64_t i_formal_ino; + uint64_t i_addr; + uint32_t i_mode; + uint32_t i_uid; + uint32_t i_gid; + uint32_t i_nlink; + uint64_t i_size; + uint64_t i_blocks; + uint64_t i_atime; + uint64_t i_mtime; + uint64_t i_ctime; + uint32_t i_major; + uint32_t i_minor; + uint64_t i_goal_meta; + uint64_t i_goal_data; + uint64_t i_generation; + uint32_t i_flags; + uint32_t i_payload_format; + uint16_t i_pad1; + uint16_t i_height; + uint32_t i_pad2; + uint16_t i_pad3; + uint16_t i_depth; + uint32_t i_entries; + uint64_t i_pad4_addr; + uint64_t i_pad4_formal_ino; + uint64_t i_eattr; + uint32_t i_atime_nsec; + uint32_t i_mtime_nsec; + uint32_t i_ctime_nsec; };
struct master_dir @@ -619,7 +653,7 @@ struct gfs_log_descriptor { uint8_t ld_reserved[64]; };
-extern int is_gfs_dir(struct gfs2_dinode *dinode); +extern int is_gfs_dir(struct gfs2_inode *ip); extern void gfs1_lookup_block(struct gfs2_inode *ip, struct gfs2_buffer_head *bh, unsigned int height, struct metapath *mp, @@ -717,8 +751,8 @@ extern void gfs2_rindex_in(struct gfs2_rindex *ri, char *buf); extern void gfs2_rindex_out(const struct gfs2_rindex *ri, char *buf); extern void gfs2_rgrp_in(struct gfs2_rgrp *rg, char *buf); extern void gfs2_rgrp_out(const struct gfs2_rgrp *rg, char *buf); -extern void gfs2_dinode_in(struct gfs2_dinode *di, char *buf); -extern void gfs2_dinode_out(struct gfs2_dinode *di, char *buf); +extern void lgfs2_dinode_in(struct gfs2_inode *ip, char *buf); +extern void lgfs2_dinode_out(struct gfs2_inode *ip, char *buf); extern void gfs2_dirent_in(struct gfs2_dirent *de, char *buf); extern void gfs2_dirent_out(struct gfs2_dirent *de, char *buf); extern void gfs2_leaf_in(struct gfs2_leaf *lf, char *buf); diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c index b45fb13d..bcc91de4 100644 --- a/gfs2/libgfs2/ondisk.c +++ b/gfs2/libgfs2/ondisk.c @@ -284,74 +284,86 @@ void lgfs2_quota_print(void *qp) printbe64(q, qu_value); }
-void gfs2_dinode_in(struct gfs2_dinode *di, char *buf) +void lgfs2_dinode_in(struct gfs2_inode *ip, char *buf) { - struct gfs2_dinode *str = (struct gfs2_dinode *)buf; - - gfs2_meta_header_in(&di->di_header, buf); - gfs2_inum_in(&di->di_num, (char *)&str->di_num); - - CPIN_32(di, str, di_mode); - CPIN_32(di, str, di_uid); - CPIN_32(di, str, di_gid); - CPIN_32(di, str, di_nlink); - CPIN_64(di, str, di_size); - CPIN_64(di, str, di_blocks); - CPIN_64(di, str, di_atime); - CPIN_64(di, str, di_mtime); - CPIN_64(di, str, di_ctime); - CPIN_32(di, str, di_major); - CPIN_32(di, str, di_minor); - - CPIN_64(di, str, di_goal_meta); - CPIN_64(di, str, di_goal_data); - - CPIN_32(di, str, di_flags); - CPIN_32(di, str, di_payload_format); - CPIN_16(di, str, __pad1); - CPIN_16(di, str, di_height); - - CPIN_16(di, str, di_depth); - CPIN_32(di, str, di_entries); - - CPIN_64(di, str, di_eattr); - - CPIN_08(di, str, di_reserved, 32); + struct gfs2_dinode *di = (struct gfs2_dinode *)buf; + + ip->i_magic = be32_to_cpu(di->di_header.mh_magic); + ip->i_type = be32_to_cpu(di->di_header.mh_type); + ip->i_format = be32_to_cpu(di->di_header.mh_format); + ip->i_formal_ino = be64_to_cpu(di->di_num.no_formal_ino); + ip->i_addr = be64_to_cpu(di->di_num.no_addr); + ip->i_mode = be32_to_cpu(di->di_mode); + ip->i_uid = be32_to_cpu(di->di_uid); + ip->i_gid = be32_to_cpu(di->di_gid); + ip->i_nlink = be32_to_cpu(di->di_nlink); + ip->i_size = be64_to_cpu(di->di_size); + ip->i_blocks = be64_to_cpu(di->di_blocks); + ip->i_atime = be64_to_cpu(di->di_atime); + ip->i_mtime = be64_to_cpu(di->di_mtime); + ip->i_ctime = be64_to_cpu(di->di_ctime); + ip->i_major = be32_to_cpu(di->di_major); + ip->i_minor = be32_to_cpu(di->di_minor); + ip->i_goal_meta = be64_to_cpu(di->di_goal_meta); + ip->i_goal_data = be64_to_cpu(di->di_goal_data); + ip->i_generation = be64_to_cpu(di->di_generation); + ip->i_flags = be32_to_cpu(di->di_flags); + ip->i_payload_format = be32_to_cpu(di->di_payload_format); + ip->i_pad1 = be16_to_cpu(di->__pad1); + ip->i_height = be16_to_cpu(di->di_height); + ip->i_pad2 = be32_to_cpu(di->__pad2); + ip->i_pad3 = be16_to_cpu(di->__pad3); + ip->i_depth = be16_to_cpu(di->di_depth); + ip->i_entries = be32_to_cpu(di->di_entries); + ip->i_pad4_addr = be64_to_cpu(di->__pad4.no_addr); + ip->i_pad4_formal_ino = be64_to_cpu(di->__pad4.no_formal_ino); + ip->i_eattr = be64_to_cpu(di->di_eattr); + ip->i_atime_nsec = be32_to_cpu(di->di_atime_nsec); + ip->i_mtime_nsec = be32_to_cpu(di->di_mtime_nsec); + ip->i_ctime_nsec = be32_to_cpu(di->di_ctime_nsec); }
-void gfs2_dinode_out(struct gfs2_dinode *di, char *buf) +void lgfs2_dinode_out(struct gfs2_inode *ip, char *buf) { - struct gfs2_dinode *str = (struct gfs2_dinode *)buf; - - gfs2_meta_header_out(&di->di_header, buf); - gfs2_inum_out(&di->di_num, (char *)&str->di_num); - - CPOUT_32(di, str, di_mode); - CPOUT_32(di, str, di_uid); - CPOUT_32(di, str, di_gid); - CPOUT_32(di, str, di_nlink); - CPOUT_64(di, str, di_size); - CPOUT_64(di, str, di_blocks); - CPOUT_64(di, str, di_atime); - CPOUT_64(di, str, di_mtime); - CPOUT_64(di, str, di_ctime); - CPOUT_32(di, str, di_major); - CPOUT_32(di, str, di_minor); - - CPOUT_64(di, str, di_goal_meta); - CPOUT_64(di, str, di_goal_data); - - CPOUT_32(di, str, di_flags); - CPOUT_32(di, str, di_payload_format); - CPOUT_16(di, str, __pad1); - CPOUT_16(di, str, di_height); - - CPOUT_16(di, str, di_depth); - CPOUT_32(di, str, di_entries); - - CPOUT_64(di, str, di_eattr); - - CPOUT_08(di, str, di_reserved, 32); + struct gfs2_dinode *di = (struct gfs2_dinode *)buf; + + di->di_header.mh_magic = cpu_to_be32(ip->i_magic); + di->di_header.mh_type = cpu_to_be32(ip->i_type); + di->di_header.mh_format = cpu_to_be32(ip->i_format); + di->di_num.no_formal_ino = cpu_to_be64(ip->i_formal_ino); + di->di_num.no_addr = cpu_to_be64(ip->i_addr); + di->di_mode = cpu_to_be32(ip->i_mode); + di->di_uid = cpu_to_be32(ip->i_uid); + di->di_gid = cpu_to_be32(ip->i_gid); + di->di_nlink = cpu_to_be32(ip->i_nlink); + di->di_size = cpu_to_be64(ip->i_size); + di->di_blocks = cpu_to_be64(ip->i_blocks); + di->di_atime = cpu_to_be64(ip->i_atime); + di->di_mtime = cpu_to_be64(ip->i_mtime); + di->di_ctime = cpu_to_be64(ip->i_ctime); + di->di_major = cpu_to_be32(ip->i_major); + di->di_minor = cpu_to_be32(ip->i_minor); + + di->di_goal_meta = cpu_to_be64(ip->i_goal_meta); + di->di_goal_data = cpu_to_be64(ip->i_goal_data); + di->di_generation = cpu_to_be64(ip->i_generation); + + di->di_flags = cpu_to_be32(ip->i_flags); + di->di_payload_format = cpu_to_be32(ip->i_payload_format); + di->__pad1 = cpu_to_be16(ip->i_pad1); + di->di_height = cpu_to_be16(ip->i_height); + di->__pad2 = cpu_to_be32(ip->i_pad2); + di->__pad3 = cpu_to_be16(ip->i_pad3); + di->di_depth = cpu_to_be16(ip->i_depth); + di->di_entries = cpu_to_be32(ip->i_entries); + + di->__pad4.no_addr = cpu_to_be64(ip->i_pad4_addr); + di->__pad4.no_formal_ino = cpu_to_be64(ip->i_pad4_formal_ino); + + di->di_eattr = cpu_to_be64(ip->i_eattr); + di->di_atime_nsec = cpu_to_be32(ip->i_atime_nsec); + di->di_mtime_nsec = cpu_to_be32(ip->i_mtime_nsec); + di->di_ctime_nsec = cpu_to_be32(ip->i_ctime_nsec); }
void lgfs2_dinode_print(void *dip) diff --git a/gfs2/libgfs2/recovery.c b/gfs2/libgfs2/recovery.c index 429b222b..7c445f15 100644 --- a/gfs2/libgfs2/recovery.c +++ b/gfs2/libgfs2/recovery.c @@ -16,7 +16,7 @@
void gfs2_replay_incr_blk(struct gfs2_inode *ip, unsigned int *blk) { - uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize; + uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
if (++*blk == jd_blocks) *blk = 0; @@ -116,7 +116,7 @@ static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk, struct lgfs2_l { unsigned int orig_blk = *blk; int error; - uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize; + uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
for (;;) { error = lgfs2_get_log_header(ip, *blk, head); @@ -145,7 +145,7 @@ static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk, struct lgfs2_l static int jhead_scan(struct gfs2_inode *ip, struct lgfs2_log_header *head) { unsigned int blk = head->lh_blkno; - uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize; + uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize; struct lgfs2_log_header lh; int error;
@@ -185,7 +185,7 @@ int lgfs2_find_jhead(struct gfs2_inode *ip, struct lgfs2_log_header *head) { struct lgfs2_log_header lh_1, lh_m; uint32_t blk_1, blk_2, blk_m; - uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize; + uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize; int error;
blk_1 = 0; diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c index d70aeaef..562640f7 100644 --- a/gfs2/libgfs2/structures.c +++ b/gfs2/libgfs2/structures.c @@ -125,8 +125,8 @@ uint32_t lgfs2_log_header_crc(char *buf, unsigned bsize) int lgfs2_write_journal_data(struct gfs2_inode *ip) { struct gfs2_sbd *sdp = ip->i_sbd; - unsigned blocks = (ip->i_di.di_size + sdp->bsize - 1) / sdp->bsize; - uint64_t jext0 = ip->i_di.di_num.no_addr + ip->i_di.di_blocks - blocks; + unsigned blocks = (ip->i_size + sdp->bsize - 1) / sdp->bsize; + uint64_t jext0 = ip->i_addr + ip->i_blocks - blocks; uint64_t seq = ((blocks) * (random() / (RAND_MAX + 1.0))); struct gfs2_log_header *lh; uint64_t jblk = jext0; @@ -141,7 +141,7 @@ int lgfs2_write_journal_data(struct gfs2_inode *ip) lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_USERSPACE); - lh->lh_jinode = cpu_to_be64(ip->i_di.di_num.no_addr); + lh->lh_jinode = cpu_to_be64(ip->i_addr);
crc32c_optimization_init(); do { @@ -178,7 +178,7 @@ static struct gfs2_buffer_head *get_file_buf(struct gfs2_inode *ip, uint64_t lbn uint64_t dbn; int new = 1;
- if (ip->i_di.di_height == 0) + if (ip->i_height == 0) unstuff_dinode(ip);
block_map(ip, lbn, &new, &dbn, NULL, prealloc); @@ -186,11 +186,11 @@ static struct gfs2_buffer_head *get_file_buf(struct gfs2_inode *ip, uint64_t lbn return NULL;
if (!prealloc && new && - ip->i_di.di_size < (lbn + 1) << sdp->sd_sb.sb_bsize_shift) { + ip->i_size < (lbn + 1) << sdp->sd_sb.sb_bsize_shift) { bmodified(ip->i_bh); - ip->i_di.di_size = (lbn + 1) << sdp->sd_sb.sb_bsize_shift; + ip->i_size = (lbn + 1) << sdp->sd_sb.sb_bsize_shift; } - if (dbn == ip->i_di.di_num.no_addr) + if (dbn == ip->i_addr) return ip->i_bh; else return bread(sdp, dbn); @@ -228,7 +228,7 @@ int write_journal(struct gfs2_inode *jnl, unsigned bsize, unsigned int blocks) lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH); lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH); lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_USERSPACE); - lh->lh_jinode = cpu_to_be64(jnl->i_di.di_num.no_addr); + lh->lh_jinode = cpu_to_be64(jnl->i_addr); lh->lh_sequence = cpu_to_be64(seq); lh->lh_blkno = cpu_to_be32(x);
@@ -346,8 +346,8 @@ int build_inum_range(struct gfs2_inode *per_node, unsigned int j) if (ip == NULL) { return errno; } - ip->i_di.di_size = sizeof(struct gfs2_inum_range); - gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data); + ip->i_size = sizeof(struct gfs2_inum_range); + lgfs2_dinode_out(ip, ip->i_bh->b_data); bmodified(ip->i_bh); if (cfg_debug) { printf("\nInum Range %u:\n", j); @@ -369,8 +369,8 @@ int build_statfs_change(struct gfs2_inode *per_node, unsigned int j) if (ip == NULL) { return errno; } - ip->i_di.di_size = sizeof(struct gfs2_statfs_change); - gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data); + ip->i_size = sizeof(struct gfs2_statfs_change); + lgfs2_dinode_out(ip, ip->i_bh->b_data); bmodified(ip->i_bh); if (cfg_debug) { printf("\nStatFS Change %u:\n", j); @@ -513,7 +513,7 @@ int build_rindex(struct gfs2_sbd *sdp) if (ip == NULL) { return errno; } - ip->i_di.di_payload_format = GFS2_FORMAT_RI; + ip->i_payload_format = GFS2_FORMAT_RI; bmodified(ip->i_bh);
for (n = osi_first(&sdp->rgtree); n; n = next) { @@ -522,14 +522,12 @@ int build_rindex(struct gfs2_sbd *sdp)
gfs2_rindex_out(&rl->ri, buf);
- count = gfs2_writei(ip, buf, ip->i_di.di_size, - sizeof(struct gfs2_rindex)); + count = gfs2_writei(ip, buf, ip->i_size, sizeof(struct gfs2_rindex)); if (count != sizeof(struct gfs2_rindex)) return -1; } memset(buf, 0, sizeof(struct gfs2_rindex)); - count = __gfs2_writei(ip, buf, ip->i_di.di_size, - sizeof(struct gfs2_rindex), 0); + count = __gfs2_writei(ip, buf, ip->i_size, sizeof(struct gfs2_rindex), 0); if (count != sizeof(struct gfs2_rindex)) return -1;
@@ -553,16 +551,16 @@ int build_quota(struct gfs2_sbd *sdp) if (ip == NULL) { return errno; } - ip->i_di.di_payload_format = GFS2_FORMAT_QU; + ip->i_payload_format = GFS2_FORMAT_QU; bmodified(ip->i_bh);
memset(&qu, 0, sizeof(struct gfs2_quota)); qu.qu_value = cpu_to_be64(1);
- count = gfs2_writei(ip, &qu, ip->i_di.di_size, sizeof(struct gfs2_quota)); + count = gfs2_writei(ip, &qu, ip->i_size, sizeof(struct gfs2_quota)); if (count != sizeof(struct gfs2_quota)) return -1; - count = gfs2_writei(ip, &qu, ip->i_di.di_size, sizeof(struct gfs2_quota)); + count = gfs2_writei(ip, &qu, ip->i_size, sizeof(struct gfs2_quota)); if (count != sizeof(struct gfs2_quota)) return -1;
diff --git a/gfs2/libgfs2/super.c b/gfs2/libgfs2/super.c index bf65b127..e8ade2e2 100644 --- a/gfs2/libgfs2/super.c +++ b/gfs2/libgfs2/super.c @@ -207,7 +207,7 @@ int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount, int *ok)
*ok = 1; *rgcount = 0; - if (sdp->md.riinode->i_di.di_size % sizeof(struct gfs2_rindex)) + if (sdp->md.riinode->i_size % sizeof(struct gfs2_rindex)) *ok = 0; /* rindex file size must be a multiple of 96 */ for (rg = 0; ; rg++) { error = gfs2_readi(sdp->md.riinode, (char *)&buf.bufgfs2, diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c index 19b248d2..32211db7 100644 --- a/gfs2/mkfs/main_mkfs.c +++ b/gfs2/mkfs/main_mkfs.c @@ -867,7 +867,7 @@ static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, struct mkfs_o return result; } /* Allocate at the beginning of the rgrp, bypassing extent search */ - in.i_di.di_num.no_addr = lgfs2_rgrp_index(rg)->ri_data0; + in.i_addr = lgfs2_rgrp_index(rg)->ri_data0; /* In order to keep writes sequential here, we have to allocate the journal, then write the rgrp header (which is now in its final form) and then write the journal out */ @@ -894,7 +894,8 @@ static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, struct mkfs_o fprintf(stderr, _("Failed to write data blocks for journal %u\n"), j); return result; } - mkfs_journals[j] = in.i_di.di_num; + mkfs_journals[j].no_addr = in.i_addr; + mkfs_journals[j].no_formal_ino = in.i_formal_ino; } gfs2_progress_close(&progress, _("Done\n"));
@@ -1197,7 +1198,8 @@ int main(int argc, char *argv[]) fprintf(stderr, _("Error building '%s': %s\n"), "master", strerror(errno)); exit(EXIT_FAILURE); } - sb.sb_master_dir = sbd.master_dir->i_di.di_num; + sb.sb_master_dir.no_addr = sbd.master_dir->i_addr; + sb.sb_master_dir.no_formal_ino = sbd.master_dir->i_formal_ino;
error = lgfs2_build_jindex(sbd.master_dir, mkfs_journals, opts.journals); if (error) { @@ -1240,7 +1242,8 @@ int main(int argc, char *argv[]) printf("%s", _("Done\n"));
build_root(&sbd); - sb.sb_root_dir = sbd.md.rooti->i_di.di_num; + sb.sb_root_dir.no_addr = sbd.md.rooti->i_addr; + sb.sb_root_dir.no_formal_ino = sbd.md.rooti->i_formal_ino;
strncpy(sb.sb_lockproto, opts.lockproto, GFS2_LOCKNAME_LEN - 1); strncpy(sb.sb_locktable, opts.locktable, GFS2_LOCKNAME_LEN - 1); diff --git a/tests/nukerg.c b/tests/nukerg.c index f2018fbf..f323d643 100644 --- a/tests/nukerg.c +++ b/tests/nukerg.c @@ -260,7 +260,7 @@ static lgfs2_rgrps_t read_rindex(struct gfs2_sbd *sdp) strerror(errno)); return NULL; } - rgcount = sdp->md.riinode->i_di.di_size / sizeof(struct gfs2_rindex); + rgcount = sdp->md.riinode->i_size / sizeof(struct gfs2_rindex); for (i = 0; i < rgcount; i++) { const struct gfs2_rindex *ri;