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 e5bc9656575b19e0177a8a0ee548053bb35d0912
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Fri May 14 15:42:30 2021 +0100
libgfs2: Remove i_di from struct gfs2_inode
To stop storing native-endian data in a struct gfs2_dinode, its fields
are duplicated into struct gfs2_inode using uint*_t types and the
in/out/print functions updated to work directly with the struct
gfs2_inode. This requires a few intermediate gfs2_inums to be used in
places that previously used i_di.di_num as a whole. They will be
resolved once a native-endian replacement for gfs2_inums is added.
Unfortunately the large size of this patch is necessary as the switch is
an all-or-nothing deal, but most of it is fairly mechanical.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/convert/gfs2_convert.c | 154 +++++++-------
gfs2/edit/extended.c | 10 +-
gfs2/edit/hexedit.c | 12 +-
gfs2/edit/journal.c | 16 +-
gfs2/fsck/afterpass1_common.c | 29 ++-
gfs2/fsck/fs_recovery.c | 29 ++-
gfs2/fsck/initialize.c | 185 ++++++++---------
gfs2/fsck/link.c | 35 ++--
gfs2/fsck/lost_n_found.c | 143 +++++++------
gfs2/fsck/main.c | 7 +-
gfs2/fsck/metawalk.c | 286 +++++++++++---------------
gfs2/fsck/pass1.c | 453 +++++++++++++++++-------------------------
gfs2/fsck/pass1b.c | 62 +++---
gfs2/fsck/pass2.c | 390 ++++++++++++++++--------------------
gfs2/fsck/pass3.c | 23 ++-
gfs2/fsck/pass4.c | 31 ++-
gfs2/fsck/rgrepair.c | 25 +--
gfs2/fsck/util.c | 47 ++---
gfs2/fsck/util.h | 12 +-
gfs2/glocktop/glocktop.c | 19 +-
gfs2/libgfs2/fs_ops.c | 215 ++++++++++----------
gfs2/libgfs2/gfs1.c | 122 +++++-------
gfs2/libgfs2/lang.c | 4 +-
gfs2/libgfs2/libgfs2.h | 42 +++-
gfs2/libgfs2/ondisk.c | 140 +++++++------
gfs2/libgfs2/recovery.c | 8 +-
gfs2/libgfs2/structures.c | 38 ++--
gfs2/libgfs2/super.c | 2 +-
gfs2/mkfs/main_mkfs.c | 11 +-
tests/nukerg.c | 2 +-
30 files changed, 1164 insertions(+), 1388 deletions(-)
diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c
index cca60598..d1cccd59 100644
--- a/gfs2/convert/gfs2_convert.c
+++ b/gfs2/convert/gfs2_convert.c
@@ -209,10 +209,10 @@ static unsigned int calc_gfs2_tree_height(struct gfs2_inode *ip,
uint64_t size)
uint64_t *arr;
unsigned int max, height;
- if (ip->i_di.di_size > size)
- size = ip->i_di.di_size;
+ if (ip->i_size > size)
+ size = ip->i_size;
- if (S_ISDIR(ip->i_di.di_mode)) {
+ if (S_ISDIR(ip->i_mode)) {
arr = gfs2_jheightsize;
max = gfs2_max_jheight;
} else {
@@ -290,7 +290,7 @@ static void fix_metatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
mh.mh_magic = GFS2_MAGIC;
mh.mh_type = GFS2_METATYPE_IN;
mh.mh_format = GFS2_FORMAT_IN;
- if (!ip->i_di.di_height)
+ if (!ip->i_height)
unstuff_dinode(ip);
ptramt = blk->mp.mp_list[blk->height] * sizeof(uint64_t);
@@ -448,7 +448,7 @@ static uint64_t fix_jdatatree(struct gfs2_sbd *sbp, struct gfs2_inode
*ip,
mh.mh_type = GFS2_METATYPE_IN;
mh.mh_format = GFS2_FORMAT_IN;
- if (!ip->i_di.di_height)
+ if (!ip->i_height)
unstuff_dinode(ip);
ptramt = blk->mp.mp_list[blk->height];
@@ -540,7 +540,7 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct
gfs2_inode *ip, str
osi_list_foreach(tmp, &blocks->list) {
blk = osi_list_entry(tmp, struct blocklist, list);
- if (blk->height >= ip->i_di.di_height - 1)
+ if (blk->height >= ip->i_height - 1)
continue;
for (ptr1 = (uint64_t *)blk->ptrbuf, ptrnum = 0;
ptrnum < sbp->sd_inptrs; ptr1++, ptrnum++) {
@@ -579,7 +579,7 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct
gfs2_inode *ip, str
brelse(bh);
/* Free the block so we can reuse it. This allows us to
convert a "full" file system. */
- ip->i_di.di_blocks--;
+ ip->i_blocks--;
gfs2_free_block(sbp, block);
}
}
@@ -622,7 +622,7 @@ static int fix_ind_reg_or_dir(struct gfs2_sbd *sbp, struct gfs2_inode
*ip, uint3
blk->height -= di_height - gfs2_hgt;
if (len) {
fix_metatree(sbp, ip, blk, ptr1, len);
- ip->i_di.di_goal_meta = be64_to_cpu(*ptr2);
+ ip->i_goal_meta = be64_to_cpu(*ptr2);
}
return 0;
@@ -671,7 +671,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
uint32_t d
newblk->mp.mp_list[h] = blk->mp.mp_list[h];
newblk->mp.mp_list[h] = ptrnum;
bh = bread(sbp, block);
- /* This is a data block. i.e newblk->height == ip->i_di.di_height */
+ /* This is a data block. i.e newblk->height == ip->i_height */
/* read in the jdata block */
memcpy(newblk->ptrbuf, bh->b_data +
sizeof(struct gfs2_meta_header), bufsize);
@@ -680,7 +680,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
uint32_t d
brelse(bh);
/* Free the block so we can reuse it. This allows us to
convert a "full" file system */
- ip->i_di.di_blocks--;
+ ip->i_blocks--;
gfs2_free_block(sbp, block);
len = bufsize;
@@ -689,7 +689,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
uint32_t d
memcpy(&newblk->mp, &gfs2mp, sizeof(struct metapath));
newblk->height -= di_height - gfs2_hgt;
if (len)
- ip->i_di.di_goal_meta = fix_jdatatree(sbp, ip, newblk,
+ ip->i_goal_meta = fix_jdatatree(sbp, ip, newblk,
newblk->ptrbuf, len);
free(newblk->ptrbuf);
free(newblk);
@@ -705,17 +705,17 @@ static int adjust_indirect_blocks(struct gfs2_sbd *sbp, struct
gfs2_inode *ip)
struct blocklist blocks, *blk;
int error = 0;
- int isdir = S_ISDIR(ip->i_di.di_mode); /* is always jdata */
- int isjdata = ((GFS2_DIF_JDATA & ip->i_di.di_flags) && !isdir);
+ int isdir = S_ISDIR(ip->i_mode); /* is always jdata */
+ int isjdata = ((GFS2_DIF_JDATA & ip->i_flags) && !isdir);
int isreg = (!isjdata && !isdir);
- int issys = (GFS2_DIF_SYSTEM & ip->i_di.di_flags);
+ int issys = (GFS2_DIF_SYSTEM & ip->i_flags);
/* regular files and dirs are same upto height=2
jdata files (not dirs) are same only when height=0 */
- if (((isreg||isdir) && ip->i_di.di_height <= 1) ||
- (isjdata && ip->i_di.di_height == 0)) {
+ if (((isreg||isdir) && ip->i_height <= 1) ||
+ (isjdata && ip->i_height == 0)) {
if (!issys)
- ip->i_di.di_goal_meta = ip->i_di.di_num.no_addr;
+ ip->i_goal_meta = ip->i_addr;
return 0; /* nothing to do */
}
@@ -727,13 +727,13 @@ static int adjust_indirect_blocks(struct gfs2_sbd *sbp, struct
gfs2_inode *ip)
/* The gfs2 height may be different. We need to rebuild the
metadata tree to the gfs2 height. */
- gfs2_hgt = calc_gfs2_tree_height(ip, ip->i_di.di_size);
+ gfs2_hgt = calc_gfs2_tree_height(ip, ip->i_size);
/* Save off the size because we're going to empty the contents
and add the data blocks back in later. */
- dinode_size = ip->i_di.di_size;
- ip->i_di.di_size = 0ULL;
- di_height = ip->i_di.di_height;
- ip->i_di.di_height = 0;
+ dinode_size = ip->i_size;
+ ip->i_size = 0ULL;
+ di_height = ip->i_height;
+ ip->i_height = 0;
/* Now run through the block list a second time. If the block
is a data block, rewrite the data to the gfs2 offset. */
@@ -762,11 +762,11 @@ static int adjust_indirect_blocks(struct gfs2_sbd *sbp, struct
gfs2_inode *ip)
free(blk);
}
- ip->i_di.di_size = dinode_size;
+ ip->i_size = dinode_size;
/* Set the new dinode height, which may or may not have changed. */
/* The caller will take it from the ip and write it to the buffer */
- ip->i_di.di_height = gfs2_hgt;
+ ip->i_height = gfs2_hgt;
return error;
out:
@@ -794,7 +794,7 @@ static int fix_cdpn_symlink(struct gfs2_sbd *sbp, struct
gfs2_buffer_head *bh, s
{
char *linkptr = NULL;
- if (ip->i_di.di_height != 0)
+ if (ip->i_height != 0)
return 0;
linkptr = bh->b_data + sizeof(struct gfs_dinode);
@@ -807,7 +807,7 @@ static int fix_cdpn_symlink(struct gfs2_sbd *sbp, struct
gfs2_buffer_head *bh, s
return -1;
}
memset(fix, 0, sizeof(struct inode_dir_block));
- fix->di_addr = ip->i_di.di_num.no_addr;
+ fix->di_addr = ip->i_addr;
osi_list_add_prev((osi_list_t *)&fix->list,
(osi_list_t *)&cdpns_to_fix);
}
@@ -817,7 +817,7 @@ static int fix_cdpn_symlink(struct gfs2_sbd *sbp, struct
gfs2_buffer_head *bh, s
/*
* fix_xattr -
- * Extended attributes can be either direct (in the ip->i_di.di_eattr block) or
+ * Extended attributes can be either direct (in the ip->i_eattr block) or
* then can be at a maximum of 1 indirect level. Multiple levels of indirection
* are not supported. If the di_eattr block contains extended attribute data,
* i.e block type = GFS_METATYPE_EA, we ignore it.
@@ -831,8 +831,8 @@ static int fix_xattr(struct gfs2_sbd *sbp, struct gfs2_buffer_head
*bh, struct g
struct gfs2_buffer_head *eabh;
char *buf;
- /* Read in the i_di.di_eattr block */
- eabh = bread(sbp, ip->i_di.di_eattr);
+ /* Read in the i_eattr block */
+ eabh = bread(sbp, ip->i_eattr);
if (!gfs2_check_meta(eabh->b_data, GFS_METATYPE_IN)) {/* if it is an indirect
block */
len = sbp->bsize - sizeof(struct gfs_indirect);
buf = malloc(len);
@@ -871,16 +871,15 @@ static int adjust_inode(struct gfs2_sbd *sbp, struct
gfs2_buffer_head *bh)
return -1;
}
- inode_was_gfs1 = (inode->i_di.di_num.no_formal_ino ==
- inode->i_di.di_num.no_addr);
+ inode_was_gfs1 = (inode->i_formal_ino == inode->i_addr);
/* Fix the inode number: */
- inode->i_di.di_num.no_formal_ino = sbp->md.next_inum;
+ inode->i_formal_ino = sbp->md.next_inum;
/* Fix the inode type: gfs1 uses di_type, gfs2 uses di_mode. */
- inode->i_di.di_mode &= ~S_IFMT;
- switch (inode->i_di.__pad1) { /* formerly di_type */
+ inode->i_mode &= ~S_IFMT;
+ switch (inode->i_pad1) { /* formerly di_type */
case GFS_FILE_DIR: /* directory */
- inode->i_di.di_mode |= S_IFDIR;
+ inode->i_mode |= S_IFDIR;
/* Add this directory to the list of dirs to fix later. */
fixdir = malloc(sizeof(struct inode_block));
if (!fixdir) {
@@ -889,27 +888,27 @@ static int adjust_inode(struct gfs2_sbd *sbp, struct
gfs2_buffer_head *bh)
goto err_freei;
}
memset(fixdir, 0, sizeof(struct inode_block));
- fixdir->di_addr = inode->i_di.di_num.no_addr;
+ fixdir->di_addr = inode->i_addr;
osi_list_add_prev((osi_list_t *)&fixdir->list,
(osi_list_t *)&dirs_to_fix);
break;
case GFS_FILE_REG: /* regular file */
- inode->i_di.di_mode |= S_IFREG;
+ inode->i_mode |= S_IFREG;
break;
case GFS_FILE_LNK: /* symlink */
- inode->i_di.di_mode |= S_IFLNK;
+ inode->i_mode |= S_IFLNK;
break;
case GFS_FILE_BLK: /* block device */
- inode->i_di.di_mode |= S_IFBLK;
+ inode->i_mode |= S_IFBLK;
break;
case GFS_FILE_CHR: /* character device */
- inode->i_di.di_mode |= S_IFCHR;
+ inode->i_mode |= S_IFCHR;
break;
case GFS_FILE_FIFO: /* fifo / pipe */
- inode->i_di.di_mode |= S_IFIFO;
+ inode->i_mode |= S_IFIFO;
break;
case GFS_FILE_SOCK: /* socket */
- inode->i_di.di_mode |= S_IFSOCK;
+ inode->i_mode |= S_IFSOCK;
break;
}
@@ -930,25 +929,26 @@ static int adjust_inode(struct gfs2_sbd *sbp, struct
gfs2_buffer_head *bh)
/* don't want to shift the data around. */
/* ----------------------------------------------------------- */
if (inode_was_gfs1) {
- struct gfs_dinode *gfs1_dinode_struct;
+ struct {
+ uint32_t dblk;
+ uint32_t mblk;
+ } *gfs1_goals = (void *)&inode->i_generation;
int ret = 0;
- gfs1_dinode_struct = (struct gfs_dinode *)&inode->i_di;
- inode->i_di.di_goal_meta = inode->i_di.di_goal_data;
- inode->i_di.di_goal_data = 0; /* make sure the upper 32b are 0 */
- inode->i_di.di_goal_data = gfs1_dinode_struct->di_goal_dblk;
- inode->i_di.di_generation = 0;
+ inode->i_goal_meta = inode->i_goal_data;
+ inode->i_goal_data = (uint64_t)gfs1_goals->dblk;
+ inode->i_generation = 0;
if (adjust_indirect_blocks(sbp, inode))
goto err_freei;
/* Check for cdpns */
- if (S_ISLNK(inode->i_di.di_mode)) {
+ if (S_ISLNK(inode->i_mode)) {
ret = fix_cdpn_symlink(sbp, bh, inode);
if (ret)
goto err_freei;
}
/* Check for extended attributes */
- if (inode->i_di.di_eattr) {
+ if (inode->i_eattr) {
ret = fix_xattr(sbp, bh, inode);
if (ret)
goto err_freei;
@@ -1124,10 +1124,10 @@ static int fetch_inum(struct gfs2_sbd *sbp, uint64_t iblock,
fix_inode = lgfs2_inode_read(sbp, iblock);
if (fix_inode == NULL)
return 1;
- inum->no_formal_ino = fix_inode->i_di.di_num.no_formal_ino;
- inum->no_addr = fix_inode->i_di.di_num.no_addr;
+ inum->no_formal_ino = fix_inode->i_formal_ino;
+ inum->no_addr = fix_inode->i_addr;
if (eablk)
- *eablk = fix_inode->i_di.di_eattr;
+ *eablk = fix_inode->i_eattr;
inode_put(&fix_inode);
return 0;
@@ -1239,7 +1239,7 @@ static int process_dirent_info(struct gfs2_inode *dip, struct
gfs2_sbd *sbp,
osi_list_foreach(tmp, &cdpns_to_fix.list) {
fix = osi_list_entry(tmp, struct inode_dir_block, list);
if (fix->di_addr == inum.no_addr)
- fix->di_paddr = dip->i_di.di_num.no_addr;
+ fix->di_paddr = dip->i_addr;
}
}
@@ -1324,14 +1324,14 @@ static int process_directory(struct gfs2_sbd *sbp, uint64_t
dirblock, uint64_t d
if (dip == NULL)
return -1;
/* fix the directory: either exhash (leaves) or linear (stuffed) */
- if (dip->i_di.di_flags & GFS2_DIF_EXHASH) {
+ if (dip->i_flags & GFS2_DIF_EXHASH) {
if (fix_one_directory_exhash(sbp, dip, dentmod)) {
log_crit(_("Error fixing exhash directory.\n"));
inode_put(&dip);
return -1;
}
} else {
- error = process_dirent_info(dip, sbp, dip->i_bh, dip->i_di.di_entries, dentmod);
+ error = process_dirent_info(dip, sbp, dip->i_bh, dip->i_entries, dentmod);
if (error && error != -EISDIR) {
log_crit(_("Error fixing linear directory.\n"));
inode_put(&dip);
@@ -1430,7 +1430,7 @@ static int fix_cdpn_symlinks(struct gfs2_sbd *sbp, osi_list_t
*cdpn_to_fix)
fix_inode = lgfs2_inode_get(sbp, bh);
if (fix_inode == NULL)
return -1;
- fix_inode->i_di.di_eattr = eablk; /*fix extended attribute */
+ fix_inode->i_eattr = eablk; /*fix extended attribute */
inode_put(&fix_inode);
bmodified(bh);
brelse(bh);
@@ -1471,17 +1471,17 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
int error=0;
unsigned int tmp_mode = 0;
- if(ip->i_di.di_size % sizeof(struct gfs_jindex) != 0){
+ if(ip->i_size % sizeof(struct gfs_jindex) != 0){
log_crit(_("The size reported in the journal index"
" inode is not a\n"
"\tmultiple of the size of a journal index.\n"));
return -1;
}
- if(!(sd_jindex = (struct gfs_jindex *)malloc(ip->i_di.di_size))) {
+ if(!(sd_jindex = (struct gfs_jindex *)malloc(ip->i_size))) {
log_crit(_("Unable to allocate journal index\n"));
return -1;
}
- if(!memset(sd_jindex, 0, ip->i_di.di_size)) {
+ if(!memset(sd_jindex, 0, ip->i_size)) {
log_crit(_("Unable to zero journal index\n"));
return -1;
}
@@ -1490,9 +1490,9 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
* so it skips the metaheader struct in the data blocks
* in the inode. gfs2_jindex inode doesn't have metaheaders
* in the data blocks */
- tmp_mode = ip->i_di.di_mode;
- ip->i_di.di_mode &= ~S_IFMT;
- ip->i_di.di_mode |= S_IFDIR;
+ tmp_mode = ip->i_mode;
+ ip->i_mode &= ~S_IFMT;
+ ip->i_mode |= S_IFDIR;
for (j = 0; ; j++) {
struct gfs_jindex *journ;
@@ -1509,8 +1509,8 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
gfs1_jindex_in(journ, buf);
sdp->jsize = (journ->ji_nsegment * 16 * sdp->bsize) >> 20;
}
- ip->i_di.di_mode = tmp_mode;
- if(j * sizeof(struct gfs_jindex) != ip->i_di.di_size){
+ ip->i_mode = tmp_mode;
+ if(j * sizeof(struct gfs_jindex) != ip->i_size){
log_crit(_("journal inode size invalid\n"));
goto fail;
}
@@ -1710,8 +1710,8 @@ static int init(struct gfs2_sbd *sbp, struct gfs2_options *opts)
/* apparently only for directories. So we need to fake out libgfs2 */
/* so that it adjusts for the metaheader by faking out the inode to */
/* look like a directory, temporarily. */
- sbp->md.riinode->i_di.di_mode &= ~S_IFMT;
- sbp->md.riinode->i_di.di_mode |= S_IFDIR;
+ sbp->md.riinode->i_mode &= ~S_IFMT;
+ sbp->md.riinode->i_mode |= S_IFDIR;
printf(_("Examining file system"));
if (gfs1_ri_update(sbp, &rgcount, 0)){
log_crit(_("Unable to fill in resource group information.\n"));
@@ -2158,15 +2158,15 @@ static void copy_quotas(struct gfs2_sbd *sdp)
exit(1);
}
- nq_ip->i_di.di_height = oq_ip->i_di.di_height;
- nq_ip->i_di.di_size = oq_ip->i_di.di_size;
- nq_ip->i_di.di_blocks = oq_ip->i_di.di_blocks;
+ nq_ip->i_height = oq_ip->i_height;
+ nq_ip->i_size = oq_ip->i_size;
+ nq_ip->i_blocks = oq_ip->i_blocks;
memcpy(nq_ip->i_bh->b_data + sizeof(struct gfs2_dinode),
oq_ip->i_bh->b_data + sizeof(struct gfs2_dinode),
sdp->bsize - sizeof(struct gfs2_dinode));
- oq_ip->i_di.di_height = 0;
- oq_ip->i_di.di_size = 0;
+ oq_ip->i_height = 0;
+ oq_ip->i_size = 0;
bmodified(nq_ip->i_bh);
inode_put(&nq_ip);
@@ -2321,7 +2321,8 @@ int main(int argc, char **argv)
"GFS2 file system structures.\n"), sb2.jsize);
/* Build the master subdirectory. */
build_master(&sb2); /* Does not do inode_put */
- sb2.sd_sb.sb_master_dir = sb2.master_dir->i_di.di_num;
+ sb2.sd_sb.sb_master_dir.no_addr = sb2.master_dir->i_addr;
+ sb2.sd_sb.sb_master_dir.no_formal_ino = sb2.master_dir->i_formal_ino;
/* Build empty journal index file. */
error = conv_build_jindex(&sb2);
if (error) {
@@ -2370,11 +2371,8 @@ int main(int argc, char **argv)
}
/* Copy out the master dinode */
- {
- struct gfs2_inode *ip = sb2.master_dir;
- if (ip->i_bh->b_modified)
- gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data);
- }
+ if (sb2.master_dir->i_bh->b_modified)
+ lgfs2_dinode_out(sb2.master_dir, sb2.master_dir->i_bh->b_data);
/* Copy old quotas */
copy_quotas(&sb2);
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index c977b6e1..f3b1bba0 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -439,7 +439,7 @@ static int print_gfs_jindex(struct gfs2_inode *dij)
start_line = line;
print_gfs2("Journal index entries found: %"PRIu64".",
- dij->i_di.di_size / sizeof(struct gfs_jindex));
+ dij->i_size / sizeof(struct gfs_jindex));
eol(0);
lines_per_row[dmode] = 4;
for (print_entry_ndx=0; ; print_entry_ndx++) {
@@ -483,7 +483,7 @@ static int print_gfs2_jindex(void)
print_gfs2("%s: 0x%-5"PRIx64" %"PRIu64"MB ",
indirect->ii[0].dirent[d].filename,
indirect->ii[0].dirent[d].block,
- ip->i_di.di_size / 1048576);
+ ip->i_size / 1048576);
error = lgfs2_find_jhead(ip, &head);
if (error) {
print_gfs2("corrupt.");
@@ -507,8 +507,8 @@ static int parse_rindex(struct gfs2_inode *dip, int print_rindex)
char highlighted_addr[32];
start_line = line;
- print_gfs2("RG index entries found: %"PRIu64".",
dip->i_di.di_size /
- sizeof(struct gfs2_rindex));
+ print_gfs2("RG index entries found: %"PRIu64".",
+ dip->i_size / sizeof(struct gfs2_rindex));
eol(0);
lines_per_row[dmode] = 6;
memset(highlighted_addr, 0, sizeof(highlighted_addr));
@@ -612,7 +612,7 @@ static int print_quota(struct gfs2_inode *diq)
print_gfs2("quota file contents:");
eol(0);
- print_gfs2("quota entries found: %"PRIu64".", diq->i_di.di_size /
sizeof(q));
+ print_gfs2("quota entries found: %"PRIu64".", diq->i_size /
sizeof(q));
eol(0);
for (i=0; ; i++) {
error = gfs2_readi(diq, &q, i * sizeof(q), sizeof(q));
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index 2e647211..4fbe071d 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -696,9 +696,8 @@ uint64_t masterblock(const char *fn)
/* ------------------------------------------------------------------------ */
static void rgcount(void)
{
- printf("%lld RGs in this file system.\n",
- (unsigned long long)sbd.md.riinode->i_di.di_size /
- sizeof(struct gfs2_rindex));
+ printf("%"PRId64" RGs in this file system.\n",
+ sbd.md.riinode->i_size / sizeof(struct gfs2_rindex));
inode_put(&sbd.md.riinode);
gfs2_rgrp_free(&sbd, &sbd.rgtree);
exit(EXIT_SUCCESS);
@@ -762,12 +761,11 @@ static uint64_t get_rg_addr(int rgnum)
riinode = lgfs2_inode_read(&sbd, gblock);
if (riinode == NULL)
return 0;
- if (rgnum < riinode->i_di.di_size / sizeof(struct gfs2_rindex))
+ if (rgnum < riinode->i_size / sizeof(struct gfs2_rindex))
rgblk = find_rgrp_block(riinode, rgnum);
else
- fprintf(stderr, "Error: File system only has %lld RGs.\n",
- (unsigned long long)riinode->i_di.di_size /
- sizeof(struct gfs2_rindex));
+ fprintf(stderr, "Error: File system only has %"PRId64" RGs.\n",
+ riinode->i_size / sizeof(struct gfs2_rindex));
inode_put(&riinode);
return rgblk;
}
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index 607f65e5..13b8c121 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -73,14 +73,14 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size)
}
inode_put(&jiinode);
} else {
- struct gfs2_dinode jdi;
+ struct gfs2_dinode *jdi;
if (journal_num > indirect->ii[0].dirents - 2)
return 0;
jblock = indirect->ii[0].dirent[journal_num + 2].block;
j_bh = bread(&sbd, jblock);
- gfs2_dinode_in(&jdi, j_bh->b_data);
- *j_size = jdi.di_size;
+ jdi = (struct gfs2_dinode *)j_bh->b_data;
+ *j_size = be64_to_cpu(jdi->di_size);
brelse(j_bh);
}
brelse(jindex_bh);
@@ -122,12 +122,12 @@ static int fsck_readi(struct gfs2_inode *ip, void *rbuf, uint64_t
roffset,
if (ip == NULL)
return 0;
sdp = ip->i_sbd;
- isdir = !!(S_ISDIR(ip->i_di.di_mode));
+ isdir = !!(S_ISDIR(ip->i_mode));
*abs_block = 0;
- if (roffset >= ip->i_di.di_size)
+ if (roffset >= ip->i_size)
return 0;
- if ((roffset + size) > ip->i_di.di_size)
- size = ip->i_di.di_size - roffset;
+ if ((roffset + size) > ip->i_size)
+ size = ip->i_size - roffset;
if (!size)
return 0;
if (isdir) {
@@ -138,7 +138,7 @@ static int fsck_readi(struct gfs2_inode *ip, void *rbuf, uint64_t
roffset,
o = roffset & (sdp->bsize - 1);
}
- if (!ip->i_di.di_height) /* inode_is_stuffed */
+ if (!ip->i_height) /* inode_is_stuffed */
o += sizeof(struct gfs2_dinode);
else if (isdir)
o += sizeof(struct gfs2_meta_header);
diff --git a/gfs2/fsck/afterpass1_common.c b/gfs2/fsck/afterpass1_common.c
index 82b9a54c..35029202 100644
--- a/gfs2/fsck/afterpass1_common.c
+++ b/gfs2/fsck/afterpass1_common.c
@@ -86,12 +86,9 @@ static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t
block,
q = bitmap_type(ip->i_sbd, block);
if (q == GFS2_BLKST_FREE) {
- log_info( _("%s block %lld (0x%llx), part of inode "
- "%lld (0x%llx), was already free.\n"),
- btype, (unsigned long long)block,
- (unsigned long long)block,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr);
+ log_info(_("%s block %"PRIu64" (0x%"PRIx64"), part of inode
"
+ "%"PRIu64" (0x%"PRIx64"), was already
free.\n"),
+ btype, block, block, ip->i_addr, ip->i_addr);
return META_IS_GOOD;
}
if (find_remove_dup(ip, block, btype, &removed_lastmeta)) { /* a dup */
@@ -101,12 +98,10 @@ static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t
block,
else
*was_duplicate = 1;
}
- log_err( _("Not clearing duplicate reference in inode "
- "at block #%llu (0x%llx) to block #%llu (0x%llx) "
- "because it's referenced by another inode.\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)block, (unsigned long long)block);
+ log_err(_("Not clearing duplicate reference in inode at block #%"PRIu64
+ " (0x%"PRIx64") to block #%"PRIu64"
(0x%"PRIx64") "
+ "because it's referenced by another inode.\n"),
+ ip->i_addr, ip->i_addr, block, block);
} else {
check_n_fix_bitmap(ip->i_sbd, ip->i_rgd, block, 0,
GFS2_BLKST_FREE);
@@ -218,15 +213,15 @@ static int del_eattr_generic(struct gfs2_inode *ip, uint64_t block,
if (!ret) {
*bh = bread(ip->i_sbd, block);
if (!was_free)
- ip->i_di.di_blocks--;
+ ip->i_blocks--;
bmodified(ip->i_bh);
}
}
/* Even if it's a duplicate reference, we want to eliminate the
reference itself, and adjust di_blocks accordingly. */
- if (ip->i_di.di_eattr) {
- if (block == ip->i_di.di_eattr)
- ip->i_di.di_eattr = 0;
+ if (ip->i_eattr) {
+ if (block == ip->i_eattr)
+ ip->i_eattr = 0;
bmodified(ip->i_bh);
}
return ret;
@@ -308,7 +303,7 @@ int delete_eattr_extentry(struct gfs2_inode *ip, int i, uint64_t
*ea_data_ptr,
bmodified(leaf_bh);
/* Endianness doesn't matter in this case because it's
a single byte. */
- fsck_bitmap_set(ip, ip->i_di.di_eattr,
+ fsck_bitmap_set(ip, ip->i_eattr,
_("extended attribute"),
ip->i_sbd->gfs1 ? GFS2_BLKST_DINODE :
GFS2_BLKST_USED);
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index ac187853..e481c88a 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 1dcfd7c4..59b78c3c 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -284,74 +284,86 @@ void lgfs2_quota_print(void *qp)
printbe64(q, qu_value);
}
-void gfs2_dinode_in(struct gfs2_dinode *di, char *buf)
+void lgfs2_dinode_in(struct gfs2_inode *ip, char *buf)
{
- struct gfs2_dinode *str = (struct gfs2_dinode *)buf;
-
- gfs2_meta_header_in(&di->di_header, buf);
- gfs2_inum_in(&di->di_num, (char *)&str->di_num);
-
- CPIN_32(di, str, di_mode);
- CPIN_32(di, str, di_uid);
- CPIN_32(di, str, di_gid);
- CPIN_32(di, str, di_nlink);
- CPIN_64(di, str, di_size);
- CPIN_64(di, str, di_blocks);
- CPIN_64(di, str, di_atime);
- CPIN_64(di, str, di_mtime);
- CPIN_64(di, str, di_ctime);
- CPIN_32(di, str, di_major);
- CPIN_32(di, str, di_minor);
-
- CPIN_64(di, str, di_goal_meta);
- CPIN_64(di, str, di_goal_data);
-
- CPIN_32(di, str, di_flags);
- CPIN_32(di, str, di_payload_format);
- CPIN_16(di, str, __pad1);
- CPIN_16(di, str, di_height);
-
- CPIN_16(di, str, di_depth);
- CPIN_32(di, str, di_entries);
-
- CPIN_64(di, str, di_eattr);
-
- CPIN_08(di, str, di_reserved, 32);
+ struct gfs2_dinode *di = (struct gfs2_dinode *)buf;
+
+ ip->i_magic = be32_to_cpu(di->di_header.mh_magic);
+ ip->i_type = be32_to_cpu(di->di_header.mh_type);
+ ip->i_format = be32_to_cpu(di->di_header.mh_format);
+ ip->i_formal_ino = be64_to_cpu(di->di_num.no_formal_ino);
+ ip->i_addr = be64_to_cpu(di->di_num.no_addr);
+ ip->i_mode = be32_to_cpu(di->di_mode);
+ ip->i_uid = be32_to_cpu(di->di_uid);
+ ip->i_gid = be32_to_cpu(di->di_gid);
+ ip->i_nlink = be32_to_cpu(di->di_nlink);
+ ip->i_size = be64_to_cpu(di->di_size);
+ ip->i_blocks = be64_to_cpu(di->di_blocks);
+ ip->i_atime = be64_to_cpu(di->di_atime);
+ ip->i_mtime = be64_to_cpu(di->di_mtime);
+ ip->i_ctime = be64_to_cpu(di->di_ctime);
+ ip->i_major = be32_to_cpu(di->di_major);
+ ip->i_minor = be32_to_cpu(di->di_minor);
+ ip->i_goal_meta = be64_to_cpu(di->di_goal_meta);
+ ip->i_goal_data = be64_to_cpu(di->di_goal_data);
+ ip->i_generation = be64_to_cpu(di->di_generation);
+ ip->i_flags = be32_to_cpu(di->di_flags);
+ ip->i_payload_format = be32_to_cpu(di->di_payload_format);
+ ip->i_pad1 = be16_to_cpu(di->__pad1);
+ ip->i_height = be16_to_cpu(di->di_height);
+ ip->i_pad2 = be32_to_cpu(di->__pad2);
+ ip->i_pad3 = be16_to_cpu(di->__pad3);
+ ip->i_depth = be16_to_cpu(di->di_depth);
+ ip->i_entries = be32_to_cpu(di->di_entries);
+ ip->i_pad4_addr = be64_to_cpu(di->__pad4.no_addr);
+ ip->i_pad4_formal_ino = be64_to_cpu(di->__pad4.no_formal_ino);
+ ip->i_eattr = be64_to_cpu(di->di_eattr);
+ ip->i_atime_nsec = be32_to_cpu(di->di_atime_nsec);
+ ip->i_mtime_nsec = be32_to_cpu(di->di_mtime_nsec);
+ ip->i_ctime_nsec = be32_to_cpu(di->di_ctime_nsec);
}
-void gfs2_dinode_out(struct gfs2_dinode *di, char *buf)
+void lgfs2_dinode_out(struct gfs2_inode *ip, char *buf)
{
- struct gfs2_dinode *str = (struct gfs2_dinode *)buf;
-
- gfs2_meta_header_out(&di->di_header, buf);
- gfs2_inum_out(&di->di_num, (char *)&str->di_num);
-
- CPOUT_32(di, str, di_mode);
- CPOUT_32(di, str, di_uid);
- CPOUT_32(di, str, di_gid);
- CPOUT_32(di, str, di_nlink);
- CPOUT_64(di, str, di_size);
- CPOUT_64(di, str, di_blocks);
- CPOUT_64(di, str, di_atime);
- CPOUT_64(di, str, di_mtime);
- CPOUT_64(di, str, di_ctime);
- CPOUT_32(di, str, di_major);
- CPOUT_32(di, str, di_minor);
-
- CPOUT_64(di, str, di_goal_meta);
- CPOUT_64(di, str, di_goal_data);
-
- CPOUT_32(di, str, di_flags);
- CPOUT_32(di, str, di_payload_format);
- CPOUT_16(di, str, __pad1);
- CPOUT_16(di, str, di_height);
-
- CPOUT_16(di, str, di_depth);
- CPOUT_32(di, str, di_entries);
-
- CPOUT_64(di, str, di_eattr);
-
- CPOUT_08(di, str, di_reserved, 32);
+ struct gfs2_dinode *di = (struct gfs2_dinode *)buf;
+
+ di->di_header.mh_magic = cpu_to_be32(ip->i_magic);
+ di->di_header.mh_type = cpu_to_be32(ip->i_type);
+ di->di_header.mh_format = cpu_to_be32(ip->i_format);
+ di->di_num.no_formal_ino = cpu_to_be64(ip->i_formal_ino);
+ di->di_num.no_addr = cpu_to_be64(ip->i_addr);
+ di->di_mode = cpu_to_be32(ip->i_mode);
+ di->di_uid = cpu_to_be32(ip->i_uid);
+ di->di_gid = cpu_to_be32(ip->i_gid);
+ di->di_nlink = cpu_to_be32(ip->i_nlink);
+ di->di_size = cpu_to_be64(ip->i_size);
+ di->di_blocks = cpu_to_be64(ip->i_blocks);
+ di->di_atime = cpu_to_be64(ip->i_atime);
+ di->di_mtime = cpu_to_be64(ip->i_mtime);
+ di->di_ctime = cpu_to_be64(ip->i_ctime);
+ di->di_major = cpu_to_be32(ip->i_major);
+ di->di_minor = cpu_to_be32(ip->i_minor);
+
+ di->di_goal_meta = cpu_to_be64(ip->i_goal_meta);
+ di->di_goal_data = cpu_to_be64(ip->i_goal_data);
+ di->di_generation = cpu_to_be64(ip->i_generation);
+
+ di->di_flags = cpu_to_be32(ip->i_flags);
+ di->di_payload_format = cpu_to_be32(ip->i_payload_format);
+ di->__pad1 = cpu_to_be16(ip->i_pad1);
+ di->di_height = cpu_to_be16(ip->i_height);
+ di->__pad2 = cpu_to_be32(ip->i_pad2);
+ di->__pad3 = cpu_to_be16(ip->i_pad3);
+ di->di_depth = cpu_to_be16(ip->i_depth);
+ di->di_entries = cpu_to_be32(ip->i_entries);
+
+ di->__pad4.no_addr = cpu_to_be64(ip->i_pad4_addr);
+ di->__pad4.no_formal_ino = cpu_to_be64(ip->i_pad4_formal_ino);
+
+ di->di_eattr = cpu_to_be64(ip->i_eattr);
+ di->di_atime_nsec = cpu_to_be32(ip->i_atime_nsec);
+ di->di_mtime_nsec = cpu_to_be32(ip->i_mtime_nsec);
+ di->di_ctime_nsec = cpu_to_be32(ip->i_ctime_nsec);
}
void lgfs2_dinode_print(void *dip)
diff --git a/gfs2/libgfs2/recovery.c b/gfs2/libgfs2/recovery.c
index 429b222b..7c445f15 100644
--- a/gfs2/libgfs2/recovery.c
+++ b/gfs2/libgfs2/recovery.c
@@ -16,7 +16,7 @@
void gfs2_replay_incr_blk(struct gfs2_inode *ip, unsigned int *blk)
{
- uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
if (++*blk == jd_blocks)
*blk = 0;
@@ -116,7 +116,7 @@ static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk,
struct lgfs2_l
{
unsigned int orig_blk = *blk;
int error;
- uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
for (;;) {
error = lgfs2_get_log_header(ip, *blk, head);
@@ -145,7 +145,7 @@ static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk,
struct lgfs2_l
static int jhead_scan(struct gfs2_inode *ip, struct lgfs2_log_header *head)
{
unsigned int blk = head->lh_blkno;
- uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
struct lgfs2_log_header lh;
int error;
@@ -185,7 +185,7 @@ int lgfs2_find_jhead(struct gfs2_inode *ip, struct lgfs2_log_header
*head)
{
struct lgfs2_log_header lh_1, lh_m;
uint32_t blk_1, blk_2, blk_m;
- uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_sb.sb_bsize;
int error;
blk_1 = 0;
diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c
index d70aeaef..562640f7 100644
--- a/gfs2/libgfs2/structures.c
+++ b/gfs2/libgfs2/structures.c
@@ -125,8 +125,8 @@ uint32_t lgfs2_log_header_crc(char *buf, unsigned bsize)
int lgfs2_write_journal_data(struct gfs2_inode *ip)
{
struct gfs2_sbd *sdp = ip->i_sbd;
- unsigned blocks = (ip->i_di.di_size + sdp->bsize - 1) / sdp->bsize;
- uint64_t jext0 = ip->i_di.di_num.no_addr + ip->i_di.di_blocks - blocks;
+ unsigned blocks = (ip->i_size + sdp->bsize - 1) / sdp->bsize;
+ uint64_t jext0 = ip->i_addr + ip->i_blocks - blocks;
uint64_t seq = ((blocks) * (random() / (RAND_MAX + 1.0)));
struct gfs2_log_header *lh;
uint64_t jblk = jext0;
@@ -141,7 +141,7 @@ int lgfs2_write_journal_data(struct gfs2_inode *ip)
lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_USERSPACE);
- lh->lh_jinode = cpu_to_be64(ip->i_di.di_num.no_addr);
+ lh->lh_jinode = cpu_to_be64(ip->i_addr);
crc32c_optimization_init();
do {
@@ -178,7 +178,7 @@ static struct gfs2_buffer_head *get_file_buf(struct gfs2_inode *ip,
uint64_t lbn
uint64_t dbn;
int new = 1;
- if (ip->i_di.di_height == 0)
+ if (ip->i_height == 0)
unstuff_dinode(ip);
block_map(ip, lbn, &new, &dbn, NULL, prealloc);
@@ -186,11 +186,11 @@ static struct gfs2_buffer_head *get_file_buf(struct gfs2_inode *ip,
uint64_t lbn
return NULL;
if (!prealloc && new &&
- ip->i_di.di_size < (lbn + 1) << sdp->sd_sb.sb_bsize_shift) {
+ ip->i_size < (lbn + 1) << sdp->sd_sb.sb_bsize_shift) {
bmodified(ip->i_bh);
- ip->i_di.di_size = (lbn + 1) << sdp->sd_sb.sb_bsize_shift;
+ ip->i_size = (lbn + 1) << sdp->sd_sb.sb_bsize_shift;
}
- if (dbn == ip->i_di.di_num.no_addr)
+ if (dbn == ip->i_addr)
return ip->i_bh;
else
return bread(sdp, dbn);
@@ -228,7 +228,7 @@ int write_journal(struct gfs2_inode *jnl, unsigned bsize, unsigned int
blocks)
lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_USERSPACE);
- lh->lh_jinode = cpu_to_be64(jnl->i_di.di_num.no_addr);
+ lh->lh_jinode = cpu_to_be64(jnl->i_addr);
lh->lh_sequence = cpu_to_be64(seq);
lh->lh_blkno = cpu_to_be32(x);
@@ -346,8 +346,8 @@ int build_inum_range(struct gfs2_inode *per_node, unsigned int j)
if (ip == NULL) {
return errno;
}
- ip->i_di.di_size = sizeof(struct gfs2_inum_range);
- gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data);
+ ip->i_size = sizeof(struct gfs2_inum_range);
+ lgfs2_dinode_out(ip, ip->i_bh->b_data);
bmodified(ip->i_bh);
if (cfg_debug) {
printf("\nInum Range %u:\n", j);
@@ -369,8 +369,8 @@ int build_statfs_change(struct gfs2_inode *per_node, unsigned int j)
if (ip == NULL) {
return errno;
}
- ip->i_di.di_size = sizeof(struct gfs2_statfs_change);
- gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data);
+ ip->i_size = sizeof(struct gfs2_statfs_change);
+ lgfs2_dinode_out(ip, ip->i_bh->b_data);
bmodified(ip->i_bh);
if (cfg_debug) {
printf("\nStatFS Change %u:\n", j);
@@ -513,7 +513,7 @@ int build_rindex(struct gfs2_sbd *sdp)
if (ip == NULL) {
return errno;
}
- ip->i_di.di_payload_format = GFS2_FORMAT_RI;
+ ip->i_payload_format = GFS2_FORMAT_RI;
bmodified(ip->i_bh);
for (n = osi_first(&sdp->rgtree); n; n = next) {
@@ -522,14 +522,12 @@ int build_rindex(struct gfs2_sbd *sdp)
gfs2_rindex_out(&rl->ri, buf);
- count = gfs2_writei(ip, buf, ip->i_di.di_size,
- sizeof(struct gfs2_rindex));
+ count = gfs2_writei(ip, buf, ip->i_size, sizeof(struct gfs2_rindex));
if (count != sizeof(struct gfs2_rindex))
return -1;
}
memset(buf, 0, sizeof(struct gfs2_rindex));
- count = __gfs2_writei(ip, buf, ip->i_di.di_size,
- sizeof(struct gfs2_rindex), 0);
+ count = __gfs2_writei(ip, buf, ip->i_size, sizeof(struct gfs2_rindex), 0);
if (count != sizeof(struct gfs2_rindex))
return -1;
@@ -553,16 +551,16 @@ int build_quota(struct gfs2_sbd *sdp)
if (ip == NULL) {
return errno;
}
- ip->i_di.di_payload_format = GFS2_FORMAT_QU;
+ ip->i_payload_format = GFS2_FORMAT_QU;
bmodified(ip->i_bh);
memset(&qu, 0, sizeof(struct gfs2_quota));
qu.qu_value = cpu_to_be64(1);
- count = gfs2_writei(ip, &qu, ip->i_di.di_size, sizeof(struct gfs2_quota));
+ count = gfs2_writei(ip, &qu, ip->i_size, sizeof(struct gfs2_quota));
if (count != sizeof(struct gfs2_quota))
return -1;
- count = gfs2_writei(ip, &qu, ip->i_di.di_size, sizeof(struct gfs2_quota));
+ count = gfs2_writei(ip, &qu, ip->i_size, sizeof(struct gfs2_quota));
if (count != sizeof(struct gfs2_quota))
return -1;
diff --git a/gfs2/libgfs2/super.c b/gfs2/libgfs2/super.c
index bf65b127..e8ade2e2 100644
--- a/gfs2/libgfs2/super.c
+++ b/gfs2/libgfs2/super.c
@@ -207,7 +207,7 @@ int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount, int *ok)
*ok = 1;
*rgcount = 0;
- if (sdp->md.riinode->i_di.di_size % sizeof(struct gfs2_rindex))
+ if (sdp->md.riinode->i_size % sizeof(struct gfs2_rindex))
*ok = 0; /* rindex file size must be a multiple of 96 */
for (rg = 0; ; rg++) {
error = gfs2_readi(sdp->md.riinode, (char *)&buf.bufgfs2,
diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c
index 19b248d2..32211db7 100644
--- a/gfs2/mkfs/main_mkfs.c
+++ b/gfs2/mkfs/main_mkfs.c
@@ -867,7 +867,7 @@ static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs,
struct mkfs_o
return result;
}
/* Allocate at the beginning of the rgrp, bypassing extent search */
- in.i_di.di_num.no_addr = lgfs2_rgrp_index(rg)->ri_data0;
+ in.i_addr = lgfs2_rgrp_index(rg)->ri_data0;
/* In order to keep writes sequential here, we have to allocate
the journal, then write the rgrp header (which is now in its
final form) and then write the journal out */
@@ -894,7 +894,8 @@ static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs,
struct mkfs_o
fprintf(stderr, _("Failed to write data blocks for journal %u\n"), j);
return result;
}
- mkfs_journals[j] = in.i_di.di_num;
+ mkfs_journals[j].no_addr = in.i_addr;
+ mkfs_journals[j].no_formal_ino = in.i_formal_ino;
}
gfs2_progress_close(&progress, _("Done\n"));
@@ -1197,7 +1198,8 @@ int main(int argc, char *argv[])
fprintf(stderr, _("Error building '%s': %s\n"), "master",
strerror(errno));
exit(EXIT_FAILURE);
}
- sb.sb_master_dir = sbd.master_dir->i_di.di_num;
+ sb.sb_master_dir.no_addr = sbd.master_dir->i_addr;
+ sb.sb_master_dir.no_formal_ino = sbd.master_dir->i_formal_ino;
error = lgfs2_build_jindex(sbd.master_dir, mkfs_journals, opts.journals);
if (error) {
@@ -1240,7 +1242,8 @@ int main(int argc, char *argv[])
printf("%s", _("Done\n"));
build_root(&sbd);
- sb.sb_root_dir = sbd.md.rooti->i_di.di_num;
+ sb.sb_root_dir.no_addr = sbd.md.rooti->i_addr;
+ sb.sb_root_dir.no_formal_ino = sbd.md.rooti->i_formal_ino;
strncpy(sb.sb_lockproto, opts.lockproto, GFS2_LOCKNAME_LEN - 1);
strncpy(sb.sb_locktable, opts.locktable, GFS2_LOCKNAME_LEN - 1);
diff --git a/tests/nukerg.c b/tests/nukerg.c
index f2018fbf..f323d643 100644
--- a/tests/nukerg.c
+++ b/tests/nukerg.c
@@ -260,7 +260,7 @@ static lgfs2_rgrps_t read_rindex(struct gfs2_sbd *sdp)
strerror(errno));
return NULL;
}
- rgcount = sdp->md.riinode->i_di.di_size / sizeof(struct gfs2_rindex);
+ rgcount = sdp->md.riinode->i_size / sizeof(struct gfs2_rindex);
for (i = 0; i < rgcount; i++) {
const struct gfs2_rindex *ri;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.