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 767016aa71e640fa4709113fbed84887aabe985b
Author: Andrew Price <anprice(a)redhat.com>
AuthorDate: Thu May 20 18:01:10 2021 +0100
libgfs2: Remove sd_sb from struct gfs2_sbd
Replace it with native-endian counterparts of the on-disk structures.
Adding fields for the gfs1-specific fields means that some gfs1-specific
variables can be removed. Update the _in() and _out() functions to work
with a gfs2_sbd instead of the big-endian gfs2_sb.
Signed-off-by: Andrew Price <anprice(a)redhat.com>
---
gfs2/convert/gfs2_convert.c | 166 +++++++++++++++++++---------------------
gfs2/edit/extended.c | 14 ++--
gfs2/edit/gfs2hex.c | 11 ++-
gfs2/edit/hexedit.c | 147 +++++++++++++++++-------------------
gfs2/edit/hexedit.h | 1 -
gfs2/edit/journal.c | 38 +++++-----
gfs2/edit/savemeta.c | 104 +++++++++++++------------
gfs2/fsck/afterpass1_common.c | 2 +-
gfs2/fsck/fs_recovery.c | 18 ++---
gfs2/fsck/fsck.h | 1 -
gfs2/fsck/initialize.c | 167 +++++++++++++++++------------------------
gfs2/fsck/metawalk.c | 42 +++++------
gfs2/fsck/metawalk.h | 2 +-
gfs2/fsck/pass1.c | 16 ++--
gfs2/fsck/pass2.c | 8 +-
gfs2/fsck/rgrepair.c | 38 +++++-----
gfs2/fsck/util.c | 4 +-
gfs2/glocktop/glocktop.c | 14 ++--
gfs2/libgfs2/buf.c | 12 +--
gfs2/libgfs2/check_rgrp.c | 4 +-
gfs2/libgfs2/device_geometry.c | 2 +-
gfs2/libgfs2/fs_ops.c | 52 ++++++-------
gfs2/libgfs2/gfs1.c | 14 ++--
gfs2/libgfs2/gfs2l.c | 4 +-
gfs2/libgfs2/lang.c | 12 +--
gfs2/libgfs2/libgfs2.h | 38 +++++++---
gfs2/libgfs2/misc.c | 22 +++---
gfs2/libgfs2/ondisk.c | 91 +++++++++++-----------
gfs2/libgfs2/recovery.c | 12 +--
gfs2/libgfs2/rgrp.c | 38 +++++-----
gfs2/libgfs2/structures.c | 52 +++++--------
gfs2/libgfs2/super.c | 58 +++++++-------
gfs2/mkfs/main_grow.c | 18 ++---
gfs2/mkfs/main_jadd.c | 28 +++----
gfs2/mkfs/main_mkfs.c | 84 +++++++++++----------
tests/nukerg.c | 7 +-
36 files changed, 646 insertions(+), 695 deletions(-)
diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c
index 280eac42..c8ebfe3b 100644
--- a/gfs2/convert/gfs2_convert.c
+++ b/gfs2/convert/gfs2_convert.c
@@ -35,8 +35,8 @@
/* The following declares are needed because gfs2 can't have */
/* dependencies on gfs1: */
-#define RGRP_STUFFED_BLKS(sb) (((sb)->sb_bsize - sizeof(struct gfs2_rgrp)) *
GFS2_NBBY)
-#define RGRP_BITMAP_BLKS(sb) (((sb)->sb_bsize - sizeof(struct gfs2_meta_header)) *
GFS2_NBBY)
+#define RGRP_STUFFED_BLKS(bsize) (((bsize) - sizeof(struct gfs2_rgrp)) * GFS2_NBBY)
+#define RGRP_BITMAP_BLKS(bsize) (((bsize) - sizeof(struct gfs2_meta_header)) *
GFS2_NBBY)
/* Define some gfs1 constants from gfs1's gfs_ondisk.h */
#define GFS_METATYPE_NONE (0)
@@ -94,7 +94,7 @@ struct gfs2_options {
unsigned int query:1;
};
-struct gfs_sb raw_gfs1_ondisk_sb;
+struct gfs_sb gfs1_sb;
struct gfs2_sbd sb2;
struct inode_block dirs_to_fix; /* linked list of directories to fix */
struct inode_dir_block cdpns_to_fix; /* linked list of cdpn symlinks */
@@ -143,7 +143,7 @@ static void convert_bitmaps(struct gfs2_sbd *sdp, struct rgrp_tree
*rg)
sizeof(struct gfs2_rgrp);
bi = &rg->bits[blk];
- for (; x < sdp->bsize; x++)
+ for (; x < sdp->sd_bsize; x++)
for (y = 0; y < GFS2_NBBY; y++) {
state = (bi->bi_data[x] >> (GFS2_BIT_SIZE * y)) & 0x03;
if (state == 0x02) {/* unallocated metadata state invalid */
@@ -303,7 +303,7 @@ static void fix_metatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
bh = bread(sbp, block);
if (new)
- memset(bh->b_data, 0, sbp->bsize);
+ memset(bh->b_data, 0, sbp->sd_bsize);
gfs2_meta_header_out(&mh, bh->b_data);
bmodified(bh);
}
@@ -311,8 +311,8 @@ static void fix_metatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
hdrsize = blk->height ? sizeof(struct gfs2_meta_header) :
sizeof(struct gfs2_dinode);
- if (amount > sbp->bsize - hdrsize - ptramt)
- amount = sbp->bsize - hdrsize - ptramt;
+ if (amount > sbp->sd_bsize - hdrsize - ptramt)
+ amount = sbp->sd_bsize - hdrsize - ptramt;
memcpy(bh->b_data + hdrsize + ptramt, (char *)srcptr, amount);
srcptr += amount;
@@ -322,7 +322,7 @@ static void fix_metatree(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
copied += amount;
- if (hdrsize + ptramt + amount >= sbp->bsize) {
+ if (hdrsize + ptramt + amount >= sbp->sd_bsize) {
/* advance to the next metablock */
blk->mp.mp_list[blk->height] +=
(amount / sizeof(uint64_t));
@@ -400,14 +400,14 @@ static void jdata_mp_gfs1_to_gfs2(struct gfs2_sbd *sbp, int gfs1_h,
int gfs2_h,
/* figure out multiplication factors for each height - gfs1 */
memset(&gfs1factor, 0, sizeof(gfs1factor));
- gfs1factor[gfs1_h - 1] = sbp->bsize - sizeof(struct gfs2_meta_header);
+ gfs1factor[gfs1_h - 1] = sbp->sd_bsize - sizeof(struct gfs2_meta_header);
for (h = gfs1_h - 1; h > 0; h--)
gfs1factor[h - 1] = gfs1factor[h] * sbp->sd_inptrs;
/* figure out multiplication factors for each height - gfs2 */
memset(&gfs2factor, 0, sizeof(gfs2factor));
gfs2factor[gfs2_h] = 1ull;
- gfs2factor[gfs2_h - 1] = sbp->bsize;
+ gfs2factor[gfs2_h - 1] = sbp->sd_bsize;
for (h = gfs2_h - 1; h > 0; h--)
gfs2factor[h - 1] = gfs2factor[h] * gfs2_inptrs;
@@ -461,15 +461,15 @@ static uint64_t fix_jdatatree(struct gfs2_sbd *sbp, struct
gfs2_inode *ip,
bh = bread(sbp, block);
if (new)
- memset(bh->b_data, 0, sbp->bsize);
+ memset(bh->b_data, 0, sbp->sd_bsize);
if (h < (blk->height - 1)) {
gfs2_meta_header_out(&mh, bh->b_data);
bmodified(bh);
}
}
- if (amount > sbp->bsize - ptramt)
- amount = sbp->bsize - ptramt;
+ if (amount > sbp->sd_bsize - ptramt)
+ amount = sbp->sd_bsize - ptramt;
memcpy(bh->b_data + ptramt, (char *)srcptr, amount);
srcptr += amount;
@@ -479,7 +479,7 @@ static uint64_t fix_jdatatree(struct gfs2_sbd *sbp, struct gfs2_inode
*ip,
copied += amount;
- if (ptramt + amount >= sbp->bsize) {
+ if (ptramt + amount >= sbp->sd_bsize) {
/* advance to the next metablock */
blk->mp.mp_list[blk->height] += amount;
for (h = blk->height; h > 0; h--) {
@@ -504,7 +504,7 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct
gfs2_inode *ip, str
osi_list_t *tmp;
uint64_t *ptr1, block;
int h, ptrnum;
- int bufsize = sbp->bsize - sizeof(struct gfs_indirect);
+ int bufsize = sbp->sd_bsize - sizeof(struct gfs_indirect);
/* Add dinode block to the list */
blk = malloc(sizeof(struct blocklist));
@@ -524,10 +524,10 @@ static int get_inode_metablocks(struct gfs2_sbd *sbp, struct
gfs2_inode *ip, str
memset(blk->ptrbuf, 0, bufsize);
/* Fill in the pointers from the dinode buffer */
memcpy(blk->ptrbuf, dibh->b_data + sizeof(struct gfs_dinode),
- sbp->bsize - sizeof(struct gfs_dinode));
+ sbp->sd_bsize - sizeof(struct gfs_dinode));
/* Zero out the pointers so we can fill them in later. */
memset(dibh->b_data + sizeof(struct gfs_dinode), 0,
- sbp->bsize - sizeof(struct gfs_dinode));
+ sbp->sd_bsize - sizeof(struct gfs_dinode));
osi_list_add_prev(&blk->list, &blocks->list);
/* Now run the metadata chain and build lists of all metadata blocks */
@@ -588,7 +588,7 @@ static int fix_ind_reg_or_dir(struct gfs2_sbd *sbp, struct gfs2_inode
*ip, uint3
int ptrnum;
struct metapath gfs2mp;
- bufsize = sbp->bsize - sizeof(struct gfs_indirect);
+ bufsize = sbp->sd_bsize - sizeof(struct gfs_indirect);
len = bufsize;
/* Skip zero pointers at the start of the buffer. This may
@@ -634,7 +634,7 @@ static int fix_ind_jdata(struct gfs2_sbd *sbp, struct gfs2_inode *ip,
uint32_t d
struct metapath gfs2mp;
struct gfs2_buffer_head *bh;
- bufsize = sbp->bsize - sizeof(struct gfs2_meta_header);
+ bufsize = sbp->sd_bsize - sizeof(struct gfs2_meta_header);
/*
* For each metadata block that holds jdata block pointers,
* get the blk pointers and copy them block by block
@@ -828,7 +828,7 @@ static int fix_xattr(struct gfs2_sbd *sbp, struct gfs2_buffer_head
*bh, struct g
/* 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);
+ len = sbp->sd_bsize - sizeof(struct gfs_indirect);
buf = malloc(len);
if (!buf) {
/*FIXME: Same message as fix_cdpn_symlink */
@@ -837,8 +837,8 @@ static int fix_xattr(struct gfs2_sbd *sbp, struct gfs2_buffer_head
*bh, struct g
}
old_hdr_sz = sizeof(struct gfs_indirect);
new_hdr_sz = sizeof(struct gfs2_meta_header);
- memcpy(buf, eabh->b_data + old_hdr_sz, sbp->bsize - old_hdr_sz);
- memset(eabh->b_data + new_hdr_sz, 0, sbp->bsize - new_hdr_sz);
+ memcpy(buf, eabh->b_data + old_hdr_sz, sbp->sd_bsize - old_hdr_sz);
+ memset(eabh->b_data + new_hdr_sz, 0, sbp->sd_bsize - new_hdr_sz);
memcpy(eabh->b_data + new_hdr_sz, buf, len);
free(buf);
bmodified(eabh);
@@ -1058,8 +1058,8 @@ static int inode_renumber(struct gfs2_sbd *sbp, uint64_t
root_inode_addr, osi_li
break;
/* If this is the root inode block, remember it for later: */
if (block == root_inode_addr) {
- sbp->sd_sb.sb_root_dir.no_addr = block;
- sbp->sd_sb.sb_root_dir.no_formal_ino = sbp->md.next_inum;
+ sbp->sd_root_dir.no_addr = block;
+ sbp->sd_root_dir.no_formal_ino = sbp->md.next_inum;
}
bh = bread(sbp, block);
if (!gfs2_check_meta(bh->b_data, GFS_METATYPE_DI)) {/* if it is an dinode */
@@ -1085,7 +1085,7 @@ static int inode_renumber(struct gfs2_sbd *sbp, uint64_t
root_inode_addr, osi_li
buf_offset = (blk) ? sizeof(struct gfs2_meta_header) :
sizeof(struct gfs2_rgrp);
/* if it's on this page */
- if (buf_offset + bitmap_byte < sbp->bsize) {
+ if (buf_offset + bitmap_byte < sbp->sd_bsize) {
bi->bi_data[buf_offset + bitmap_byte] &=
~(0x03 << (GFS2_BIT_SIZE * byte_bit));
bi->bi_data[buf_offset + bitmap_byte] |=
@@ -1093,7 +1093,7 @@ static int inode_renumber(struct gfs2_sbd *sbp, uint64_t
root_inode_addr, osi_li
bi->bi_modified = 1;
break;
}
- bitmap_byte -= (sbp->bsize - buf_offset);
+ bitmap_byte -= (sbp->sd_bsize - buf_offset);
}
}
brelse(bh);
@@ -1346,7 +1346,7 @@ static int fix_directory_info(struct gfs2_sbd *sbp, osi_list_t
*dir_to_fix)
uint64_t dirblock;
uint32_t gfs1_inptrs = sbp->sd_inptrs;
/* Directory inodes have been converted to gfs2, use gfs2 inptrs */
- sbp->sd_inptrs = (sbp->bsize - sizeof(struct gfs2_meta_header))
+ sbp->sd_inptrs = (sbp->sd_bsize - sizeof(struct gfs2_meta_header))
/ sizeof(uint64_t);
dirs_fixed = 0;
@@ -1500,7 +1500,7 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
}
journ = sd_jindex + j;
gfs1_jindex_in(journ, buf);
- sdp->jsize = (journ->ji_nsegment * 16 * sdp->bsize) >> 20;
+ sdp->jsize = (journ->ji_nsegment * 16 * sdp->sd_bsize) >> 20;
}
ip->i_mode = tmp_mode;
if(j * sizeof(struct gfs_jindex) != ip->i_size){
@@ -1518,15 +1518,15 @@ static int read_gfs1_jiindex(struct gfs2_sbd *sdp)
static int sanity_check(struct gfs2_sbd *sdp)
{
int error = 0;
- if (!raw_gfs1_ondisk_sb.sb_quota_di.no_addr) {
+ if (!gfs1_sb.sb_quota_di.no_addr) {
log_crit(_("Error: Superblock Quota inode address is NULL\n"));
error = 1;
}
- if (!raw_gfs1_ondisk_sb.sb_license_di.no_addr) {
+ if (!gfs1_sb.sb_license_di.no_addr) {
log_crit(_("Error: Superblock Statfs inode address is NULL\n"));
error = 1;
}
- if (!raw_gfs1_ondisk_sb.sb_seg_size) {
+ if (!gfs1_sb.sb_seg_size) {
log_crit(_("Error: Superblock segment size is zero\n"));
error = 1;
}
@@ -1595,13 +1595,6 @@ static int init(struct gfs2_sbd *sbp, struct gfs2_options *opts)
perror(opts->device);
exit(-1);
}
- /* --------------------------------- */
- /* initialize the incore superblock */
- /* --------------------------------- */
- sbp->sd_sb.sb_header.mh_magic = GFS2_MAGIC;
- sbp->sd_sb.sb_header.mh_type = GFS2_METATYPE_SB;
- sbp->sd_sb.sb_header.mh_format = GFS2_FORMAT_SB;
-
osi_list_init((osi_list_t *)&dirs_to_fix);
osi_list_init((osi_list_t *)&cdpns_to_fix);
/* ---------------------------------------------- */
@@ -1614,8 +1607,7 @@ static int init(struct gfs2_sbd *sbp, struct gfs2_options *opts)
sbp->blks_total = 0; /* total blocks - total them up later */
sbp->blks_alloced = 0; /* blocks allocated - total them up later */
sbp->dinodes_alloced = 0; /* dinodes allocated - total them up later */
- sbp->sd_sb.sb_bsize = GFS2_DEFAULT_BSIZE;
- sbp->bsize = sbp->sd_sb.sb_bsize;
+ sbp->sd_bsize = GFS2_DEFAULT_BSIZE;
sbp->rgtree.osi_node = NULL;
if (compute_constants(sbp)) {
log_crit("%s\n", _("Failed to compute file system constants"));
@@ -1623,28 +1615,27 @@ static int init(struct gfs2_sbd *sbp, struct gfs2_options *opts)
}
bh = bread(sbp, GFS2_SB_ADDR >> sbp->sd_fsb2bb_shift);
- memcpy(&raw_gfs1_ondisk_sb, (struct gfs_sb *)bh->b_data,
- sizeof(struct gfs_sb));
- gfs2_sb_in(&sbp->sd_sb, bh->b_data);
+ memcpy(&gfs1_sb, bh->b_data, sizeof(struct gfs_sb));
+ lgfs2_sb_in(sbp, bh->b_data);
- jindex_addr = be64_to_cpu(raw_gfs1_ondisk_sb.sb_jindex_di.no_addr);
- rindex_addr = be64_to_cpu(raw_gfs1_ondisk_sb.sb_rindex_di.no_addr);
+ jindex_addr = be64_to_cpu(gfs1_sb.sb_jindex_di.no_addr);
+ rindex_addr = be64_to_cpu(gfs1_sb.sb_rindex_di.no_addr);
- sbp->bsize = sbp->sd_sb.sb_bsize;
- sbp->fssize = lseek(sbp->device_fd, 0, SEEK_END) / sbp->sd_sb.sb_bsize;
- sbp->sd_inptrs = (sbp->bsize - sizeof(struct gfs_indirect)) /
+ sbp->sd_bsize = sbp->sd_bsize;
+ sbp->fssize = lseek(sbp->device_fd, 0, SEEK_END) / sbp->sd_bsize;
+ sbp->sd_inptrs = (sbp->sd_bsize - sizeof(struct gfs_indirect)) /
sizeof(uint64_t);
- sbp->sd_diptrs = (sbp->bsize - sizeof(struct gfs_dinode)) /
+ sbp->sd_diptrs = (sbp->sd_bsize - sizeof(struct gfs_dinode)) /
sizeof(uint64_t);
- sbp->sd_jbsize = sbp->bsize - sizeof(struct gfs2_meta_header);
+ sbp->sd_jbsize = sbp->sd_bsize - sizeof(struct gfs2_meta_header);
brelse(bh);
- if (compute_heightsize(sbp->bsize, sbp->sd_heightsize,
&sbp->sd_max_height,
- sbp->bsize, sbp->sd_diptrs, sbp->sd_inptrs)) {
+ if (compute_heightsize(sbp->sd_bsize, sbp->sd_heightsize,
&sbp->sd_max_height,
+ sbp->sd_bsize, sbp->sd_diptrs, sbp->sd_inptrs)) {
log_crit("%s\n", _("Failed to compute file system constants"));
exit(-1);
}
- if (compute_heightsize(sbp->bsize, sbp->sd_jheightsize,
&sbp->sd_max_jheight,
+ if (compute_heightsize(sbp->sd_bsize, sbp->sd_jheightsize,
&sbp->sd_max_jheight,
sbp->sd_jbsize, sbp->sd_diptrs, sbp->sd_inptrs)) {
log_crit("%s\n", _("Failed to compute file system constants"));
exit(-1);
@@ -1652,41 +1643,38 @@ static int init(struct gfs2_sbd *sbp, struct gfs2_options *opts)
/* -------------------------------------------------------- */
/* Our constants are for gfs1. Need some for gfs2 as well. */
/* -------------------------------------------------------- */
- gfs2_inptrs = (sbp->bsize - sizeof(struct gfs2_meta_header)) /
+ gfs2_inptrs = (sbp->sd_bsize - sizeof(struct gfs2_meta_header)) /
sizeof(uint64_t); /* How many ptrs can we fit on a block? */
memset(gfs2_heightsize, 0, sizeof(gfs2_heightsize));
- if (compute_heightsize(sbp->bsize, gfs2_heightsize, &gfs2_max_height,
- sbp->bsize, sbp->sd_diptrs, gfs2_inptrs)) {
+ if (compute_heightsize(sbp->sd_bsize, gfs2_heightsize, &gfs2_max_height,
+ sbp->sd_bsize, sbp->sd_diptrs, gfs2_inptrs)) {
log_crit("%s\n", _("Failed to compute file system constants"));
exit(-1);
}
memset(gfs2_jheightsize, 0, sizeof(gfs2_jheightsize));
- if (compute_heightsize(sbp->bsize, gfs2_jheightsize, &gfs2_max_jheight,
+ if (compute_heightsize(sbp->sd_bsize, gfs2_jheightsize, &gfs2_max_jheight,
sbp->sd_jbsize, sbp->sd_diptrs, gfs2_inptrs)) {
log_crit("%s\n", _("Failed to compute file system constants"));
exit(-1);
}
-
- /* ---------------------------------------------- */
- /* Make sure we're really gfs1 */
- /* ---------------------------------------------- */
- if (sbp->sd_sb.sb_fs_format != GFS_FORMAT_FS ||
- sbp->sd_sb.sb_header.mh_type != GFS_METATYPE_SB ||
- sbp->sd_sb.sb_header.mh_format != GFS_FORMAT_SB ||
- sbp->sd_sb.sb_multihost_format != GFS_FORMAT_MULTI) {
+ /* Make sure we're really gfs1 */
+ if (be32_to_cpu(gfs1_sb.sb_fs_format) != GFS_FORMAT_FS ||
+ be32_to_cpu(gfs1_sb.sb_header.mh_type) != GFS_METATYPE_SB ||
+ be32_to_cpu(gfs1_sb.sb_header.mh_format) != GFS_FORMAT_SB ||
+ be32_to_cpu(gfs1_sb.sb_multihost_format) != GFS_FORMAT_MULTI) {
log_crit(_("Error: %s does not look like a gfs1 filesystem.\n"),
opts->device);
close(sbp->device_fd);
exit(-1);
}
/* get gfs1 rindex inode - gfs1's rindex inode ptr became __pad2 */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_rindex_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_rindex_di);
sbp->md.riinode = lgfs2_gfs_inode_read(sbp, inum.no_addr);
if (sbp->md.riinode == NULL) {
log_crit(_("Could not read resource group index: %s\n"), strerror(errno));
exit(-1);
}
/* get gfs1 jindex inode - gfs1's journal index inode ptr became master */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_jindex_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_jindex_di);
sbp->md.jiinode = lgfs2_inode_read(sbp, inum.no_addr);
if (sbp->md.jiinode == NULL) {
log_crit(_("Could not read journal index: %s\n"), strerror(errno));
@@ -1813,8 +1801,8 @@ static void process_parameters(int argc, char **argv, struct
gfs2_options *opts)
/* ------------------------------------------------------------------------- */
static uint64_t rgrp_length(uint64_t size, struct gfs2_sbd *sdp)
{
- uint64_t bitbytes = RGRP_BITMAP_BLKS(&sdp->sd_sb) + 1;
- uint64_t stuff = RGRP_STUFFED_BLKS(&sdp->sd_sb) + 1;
+ uint64_t bitbytes = RGRP_BITMAP_BLKS(sdp->sd_bsize) + 1;
+ uint64_t stuff = RGRP_STUFFED_BLKS(sdp->sd_bsize) + 1;
uint64_t blocks = 1;
if (size >= stuff) {
@@ -1885,7 +1873,7 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
rgd = rgrp_insert(&sdp->rgtree, ri_addr);
/* convert the gfs1 rgrp into a new gfs2 rgrp */
size = jndx->ji_nsegment *
- be32_to_cpu(raw_gfs1_ondisk_sb.sb_seg_size);
+ be32_to_cpu(gfs1_sb.sb_seg_size);
rgd->rt_flags = 0;
rgd->rt_dinodes = 0;
@@ -1901,18 +1889,18 @@ static int journ_space_to_rg(struct gfs2_sbd *sdp)
rgd->rt_free = rgd->rt_data;
rgd->rt_bitbytes = rgd->rt_data / GFS2_NBBY;
- if (gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, rgd)) {
+ if (gfs2_compute_bitstructs(sdp->sd_bsize, rgd)) {
log_crit(_("gfs2_convert: Error converting bitmaps.\n"));
exit(-1);
}
- rgd->bits[0].bi_data = calloc(rgd->rt_length, sdp->bsize);
+ rgd->bits[0].bi_data = calloc(rgd->rt_length, sdp->sd_bsize);
if (rgd->bits[0].bi_data == NULL) {
perror("");
exit(-1);
}
for (unsigned i = 1; i < rgd->rt_length; i++)
- rgd->bits[i].bi_data = rgd->bits[0].bi_data + (i * sdp->bsize);
+ rgd->bits[i].bi_data = rgd->bits[0].bi_data + (i * sdp->sd_bsize);
convert_bitmaps(sdp, rgd);
lgfs2_rgrp_out(rgd, rgd->bits[0].bi_data);
@@ -1975,19 +1963,19 @@ static void remove_obsolete_gfs1(struct gfs2_sbd *sbp)
log_notice(_("Removing obsolete GFS1 file system structures.\n"));
fflush(stdout);
/* Delete the old gfs1 Journal index: */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_jindex_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_jindex_di);
gfs2_freedi(sbp, inum.no_addr);
/* Delete the old gfs1 rgindex: */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_rindex_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_rindex_di);
gfs2_freedi(sbp, inum.no_addr);
/* Delete the old gfs1 Quota file: */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_quota_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_quota_di);
gfs2_freedi(sbp, inum.no_addr);
/* Delete the old gfs1 License file: */
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_license_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_license_di);
gfs2_freedi(sbp, inum.no_addr);
}
@@ -2017,8 +2005,8 @@ static int conv_build_jindex(struct gfs2_sbd *sdp)
sprintf(name, "journal%u", j);
sdp->md.journal[j] = createi(sdp->md.jiinode, name, S_IFREG |
0600, GFS2_DIF_SYSTEM);
- write_journal(sdp->md.journal[j], sdp->bsize,
- sdp->jsize << 20 >> sdp->sd_sb.sb_bsize_shift);
+ write_journal(sdp->md.journal[j], sdp->sd_bsize,
+ sdp->jsize << 20 >> sdp->sd_bsize_shift);
inode_put(&sdp->md.journal[j]);
printf(_("done.\n"));
fflush(stdout);
@@ -2037,7 +2025,7 @@ static unsigned int total_file_blocks(struct gfs2_sbd *sdp,
uint64_t *arr;
/* Now find the total meta blocks required for data_blks */
- if (filesize <= sdp->bsize - sizeof(struct gfs2_dinode)) {
+ if (filesize <= sdp->sd_bsize - sizeof(struct gfs2_dinode)) {
goto out;
}
@@ -2048,7 +2036,7 @@ static unsigned int total_file_blocks(struct gfs2_sbd *sdp,
} else {
arr = sdp->sd_heightsize;
max = sdp->sd_max_height;
- bsize = sdp->bsize;
+ bsize = sdp->sd_bsize;
}
data_blks = DIV_RU(filesize, bsize); /* total data blocks reqd */
@@ -2138,7 +2126,7 @@ static void copy_quotas(struct gfs2_sbd *sdp)
exit(1);
}
- gfs2_inum_in(&inum, (char *)&raw_gfs1_ondisk_sb.sb_quota_di);
+ gfs2_inum_in(&inum, (char *)&gfs1_sb.sb_quota_di);
oq_ip = lgfs2_inode_read(sdp, inum.no_addr);
if (oq_ip == NULL) {
fprintf(stderr, _("Couldn't lookup old quota file: %s\n"),
strerror(errno));
@@ -2150,7 +2138,7 @@ static void copy_quotas(struct gfs2_sbd *sdp)
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));
+ sdp->sd_bsize - sizeof(struct gfs2_dinode));
oq_ip->i_height = 0;
oq_ip->i_size = 0;
@@ -2246,7 +2234,7 @@ int main(int argc, char **argv)
/* ---------------------------------------------- */
if (!error) {
/* Add a string notifying inode converstion start? */
- error = inode_renumber(&sb2, sb2.sd_sb.sb_root_dir.no_addr,
+ error = inode_renumber(&sb2, sb2.sd_root_dir.no_addr,
(osi_list_t *)&cdpns_to_fix);
if (error)
log_crit(_("\n%s: Error renumbering inodes.\n"), opts.device);
@@ -2308,8 +2296,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.no_addr = sb2.master_dir->i_addr;
- sb2.sd_sb.sb_master_dir.no_formal_ino = sb2.master_dir->i_formal_ino;
+ sb2.sd_meta_dir.no_addr = sb2.master_dir->i_addr;
+ sb2.sd_meta_dir.no_formal_ino = sb2.master_dir->i_formal_ino;
/* Build empty journal index file. */
error = conv_build_jindex(&sb2);
if (error) {
@@ -2384,9 +2372,9 @@ int main(int argc, char **argv)
/* it to not reject the partially converted fs as already done */
/* when it's run a second time. */
bh = bread(&sb2, LGFS2_SB_ADDR(&sb2));
- sb2.sd_sb.sb_fs_format = GFS2_FORMAT_FS;
- sb2.sd_sb.sb_multihost_format = GFS2_FORMAT_MULTI;
- gfs2_sb_out(&sb2.sd_sb, bh->b_data);
+ sb2.sd_fs_format = GFS2_FORMAT_FS;
+ sb2.sd_multihost_format = GFS2_FORMAT_MULTI;
+ lgfs2_sb_out(&sb2, bh->b_data);
bmodified(bh);
brelse(bh);
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index e9e2a7eb..4d6b7496 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -62,7 +62,7 @@ static int _do_indirect_extended(char *diebuf, struct iinfo *iinf, int
hgt)
memset(&iinf->ii[x].dirent, 0, sizeof(struct gfs2_dirents));
}
headoff = sbd.gfs1 ? sizeof(struct gfs_indirect) : sizeof(struct gfs2_meta_header);
- for (x = headoff, y = 0; x < sbd.bsize; x += sizeof(uint64_t), y++) {
+ for (x = headoff, y = 0; x < sbd.sd_bsize; x += sizeof(uint64_t), y++) {
p = be64_to_cpu(*(uint64_t *)(diebuf + x));
if (p) {
iinf->ii[i_blocks].block = p;
@@ -196,7 +196,7 @@ static int display_indirect(struct iinfo *ind, int indblocks, int
level,
file_offset = metapath_to_lblock(&ind->ii[pndx].mp,
cur_height) *
- sbd.bsize;
+ sbd.sd_bsize;
print_gfs2(" ");
h = 'K';
human_off = (file_offset / 1024.0);
@@ -378,7 +378,7 @@ static void print_block_details(struct iinfo *ind, int level, int
cur_height,
"display_indirect\n");
return;
}
- tmpbuf = malloc(sbd.bsize);
+ tmpbuf = malloc(sbd.sd_bsize);
if (!tmpbuf) {
fprintf(stderr, "Out of memory in function "
"display_indirect\n");
@@ -387,7 +387,7 @@ static void print_block_details(struct iinfo *ind, int level, int
cur_height,
}
while (thisblk) {
/* read in the desired block */
- if (pread(sbd.device_fd, tmpbuf, sbd.bsize, thisblk * sbd.bsize) != sbd.bsize) {
+ if (pread(sbd.device_fd, tmpbuf, sbd.sd_bsize, thisblk * sbd.sd_bsize) != sbd.sd_bsize)
{
fprintf(stderr, "bad read: %s from %s:%d: block %"PRIu64
" (0x%"PRIx64")\n", strerror(errno), __FUNCTION__,
__LINE__, ind->ii[pndx].block, ind->ii[pndx].block);
@@ -543,7 +543,7 @@ static int parse_rindex(struct gfs2_inode *dip, int print_rindex)
struct gfs2_rgrp r = {0};
ssize_t ret;
- ret = pread(sbd.device_fd, &r, sizeof(r), rg.rt_addr * sbd.bsize);
+ ret = pread(sbd.device_fd, &r, sizeof(r), rg.rt_addr * sbd.sd_bsize);
if (ret != sizeof(r)) {
perror("Failed to read resource group");
} else if (sbd.gfs1) {
@@ -646,7 +646,7 @@ int display_extended(void)
brelse(tmp_bh);
} else if (block_is_journals(block)) {
if (sbd.gfs1)
- block = sbd1->sb_jindex_di.no_addr;
+ block = sbd.sd_jindex_di.no_addr;
else
block = masterblock("jindex");
print_gfs2_jindex();
@@ -657,7 +657,7 @@ int display_extended(void)
return -1;
else if (block_is_rgtree(block)) {
if (sbd.gfs1)
- tmp_bh = bread(&sbd, sbd1->sb_rindex_di.no_addr);
+ tmp_bh = bread(&sbd, sbd.sd_rindex_di.no_addr);
else
tmp_bh = bread(&sbd, masterblock("rindex"));
tmp_inode = lgfs2_inode_get(&sbd, tmp_bh);
diff --git a/gfs2/edit/gfs2hex.c b/gfs2/edit/gfs2hex.c
index 092b35b6..f0c409b5 100644
--- a/gfs2/edit/gfs2hex.c
+++ b/gfs2/edit/gfs2hex.c
@@ -46,7 +46,6 @@ struct blkstack_info blockstack[BLOCK_STACK_SIZE];
int identify = FALSE;
uint64_t max_block = 0;
int start_row[DMODES], end_row[DMODES], lines_per_row[DMODES];
-struct gfs_sb *sbd1;
int gfs2_struct_type;
unsigned int offset;
struct indirect_info masterdir;
@@ -246,7 +245,7 @@ void do_dinode_extended(char *buf)
memset(indirect, 0, sizeof(struct iinfo));
if (be16_to_cpu(dip->di_height) > 0) {
/* Indirect pointers */
- for (x = sizeof(struct gfs2_dinode); x < sbd.bsize;
+ for (x = sizeof(struct gfs2_dinode); x < sbd.sd_bsize;
x += sizeof(uint64_t)) {
p = be64_to_cpu(*(uint64_t *)(buf + x));
if (p) {
@@ -268,7 +267,7 @@ void do_dinode_extended(char *buf)
indirect->ii[0].dirents = 0;
indirect->ii[0].block = block;
indirect->ii[0].is_dir = TRUE;
- for (x = sizeof(struct gfs2_dinode); x < sbd.bsize; x += skip) {
+ for (x = sizeof(struct gfs2_dinode); x < sbd.sd_bsize; x += skip) {
skip = indirect_dirent(indirect->ii, buf + x,
indirect->ii[0].dirents);
if (skip <= 0)
@@ -298,7 +297,7 @@ void do_dinode_extended(char *buf)
gfs2_leaf_in(&leaf, tmp_bh->b_data);
indirect->ii[indirect_blocks].dirents = 0;
for (direntcount = 0, bufoffset = sizeof(struct gfs2_leaf);
- bufoffset < sbd.bsize;
+ bufoffset < sbd.sd_bsize;
direntcount++, bufoffset += skip) {
skip = indirect_dirent(&indirect->ii[indirect_blocks],
tmp_bh->b_data + bufoffset,
@@ -327,7 +326,7 @@ uint64_t do_leaf_extended(char *dlebuf, struct iinfo *indir)
memset(indir, 0, sizeof(*indir));
gfs2_leaf_in(&indir->ii[0].lf, dlebuf);
/* Directory Entries: */
- for (i = sizeof(struct gfs2_leaf); i < sbd.bsize;
+ for (i = sizeof(struct gfs2_leaf); i < sbd.sd_bsize;
i += de.de_rec_len) {
gfs2_dirent_in(&de, dlebuf + i);
if (de.de_inum.no_addr) {
@@ -359,7 +358,7 @@ static void do_eattr_extended(char *buf)
print_gfs2("Eattr Entries:");
eol(0);
- for (x = sizeof(struct gfs2_meta_header); x < sbd.bsize; x += rec_len)
+ for (x = sizeof(struct gfs2_meta_header); x < sbd.sd_bsize; x += rec_len)
{
eol(0);
buf += x;
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index 18afd0ed..2843262b 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -347,7 +347,7 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
struct_len = mtype->size;
ret_type = mtype->mh_type;
} else {
- struct_len = sbd.bsize;
+ struct_len = sbd.sd_bsize;
ret_type = 0;
}
}
@@ -376,8 +376,8 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
pgnum = (offset / screen_chunk_size);
if (type >= 0) {
print_gfs2("(p.%d of %d--%s)", pgnum + 1,
- (sbd.bsize % screen_chunk_size) > 0 ?
- sbd.bsize / screen_chunk_size + 1 : sbd.bsize /
+ (sbd.sd_bsize % screen_chunk_size) > 0 ?
+ sbd.sd_bsize / screen_chunk_size + 1 : sbd.sd_bsize /
screen_chunk_size, allocdesc[sbd.gfs1][type]);
}
/*eol(9);*/
@@ -415,7 +415,7 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
struct_len = (b ?
sizeof(struct gfs2_meta_header) :
sizeof(struct gfs2_rgrp));
- blknum += (sbd.bsize - struct_len);
+ blknum += (sbd.sd_bsize - struct_len);
}
struct_len = sizeof(struct gfs2_meta_header);
/* add the number of bytes on this screen */
@@ -439,9 +439,9 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
if (rgd)
gfs2_rgrp_relse(&sbd, rgd);
}
- if (block == sbd.sd_sb.sb_root_dir.no_addr)
+ if (block == sbd.sd_root_dir.no_addr)
print_gfs2("--------------- Root directory ------------------");
- else if (!sbd.gfs1 && block == sbd.sd_sb.sb_master_dir.no_addr)
+ else if (!sbd.gfs1 && block == sbd.sd_meta_dir.no_addr)
print_gfs2("-------------- Master directory -----------------");
else if (!sbd.gfs1 && block == RGLIST_DUMMY_BLOCK)
print_gfs2("------------------ RG List ----------------------");
@@ -449,11 +449,11 @@ int display_block_type(char *buf, uint64_t addr, int from_restore)
print_gfs2("-------------------- Journal List --------------------");
else {
if (sbd.gfs1) {
- if (block == sbd1->sb_rindex_di.no_addr)
+ if (block == sbd.sd_rindex_di.no_addr)
print_gfs2("---------------- rindex file -------------------");
else if (block == gfs1_quota_di.no_addr)
print_gfs2("---------------- Quota file --------------------");
- else if (block == sbd1->sb_jindex_di.no_addr)
+ else if (block == sbd.sd_jindex_di.no_addr)
print_gfs2("--------------- Journal Index ------------------");
else if (block == gfs1_license_di.no_addr)
print_gfs2("--------------- License file -------------------");
@@ -504,7 +504,7 @@ static int hexdump(uint64_t startaddr, uint64_t len, int trunc_zeros,
int i;
uint64_t l;
const char *lpBuffer = bh->b_data;
- const char *zeros_strt = lpBuffer + sbd.bsize;
+ const char *zeros_strt = lpBuffer + sbd.sd_bsize;
int print_field, cursor_line;
const struct lgfs2_metadata *m = get_block_type(bh->b_data);
uint64_t *ref;
@@ -522,7 +522,7 @@ static int hexdump(uint64_t startaddr, uint64_t len, int trunc_zeros,
print_entry_ndx = 0;
while (((termlines && line < termlines &&
line <= ((screen_chunk_size / 16) + 2)) ||
- (!termlines && l < len)) && l < sbd.bsize) {
+ (!termlines && l < len)) && l < sbd.sd_bsize) {
int ptr_not_null = 0;
if (termlines) {
@@ -715,7 +715,7 @@ static uint64_t find_rgrp_block(struct gfs2_inode *dif, int rg)
foffset = rg * sizeof(struct gfs2_rindex);
if (sbd.gfs1) {
uint64_t sd_jbsize =
- (sbd.bsize - sizeof(struct gfs2_meta_header));
+ (sbd.sd_bsize - sizeof(struct gfs2_meta_header));
gfs1_adj = (foffset / sd_jbsize) *
sizeof(struct gfs2_meta_header);
@@ -753,7 +753,7 @@ static uint64_t get_rg_addr(int rgnum)
struct gfs2_inode *riinode;
if (sbd.gfs1)
- gblock = sbd1->sb_rindex_di.no_addr;
+ gblock = sbd.sd_rindex_di.no_addr;
else
gblock = masterblock("rindex");
riinode = lgfs2_inode_read(&sbd, gblock);
@@ -827,7 +827,7 @@ int has_indirect_blocks(void)
int block_is_rindex(uint64_t blk)
{
- if ((sbd.gfs1 && blk == sbd1->sb_rindex_di.no_addr) ||
+ if ((sbd.gfs1 && blk == sbd.sd_rindex_di.no_addr) ||
(blk == masterblock("rindex")))
return TRUE;
return FALSE;
@@ -835,7 +835,7 @@ int block_is_rindex(uint64_t blk)
int block_is_jindex(uint64_t blk)
{
- if ((sbd.gfs1 && blk == sbd1->sb_jindex_di.no_addr))
+ if ((sbd.gfs1 && blk == sbd.sd_jindex_di.no_addr))
return TRUE;
return FALSE;
}
@@ -891,10 +891,11 @@ static int block_has_extended_info(void)
static void read_superblock(int fd)
{
- sbd1 = (struct gfs_sb *)&sbd.sd_sb;
+ struct gfs2_meta_header *mh;
+
ioctl(fd, BLKFLSBUF, 0);
memset(&sbd, 0, sizeof(struct gfs2_sbd));
- sbd.bsize = GFS2_DEFAULT_BSIZE;
+ sbd.sd_bsize = GFS2_DEFAULT_BSIZE;
sbd.device_fd = fd;
bh = bread(&sbd, 0x10);
sbd.jsize = GFS2_DEFAULT_JSIZE;
@@ -902,26 +903,19 @@ static void read_superblock(int fd)
sbd.qcsize = GFS2_DEFAULT_QCSIZE;
sbd.time = time(NULL);
sbd.rgtree.osi_node = NULL;
- gfs2_sb_in(&sbd.sd_sb, bh->b_data);
+ lgfs2_sb_in(&sbd, bh->b_data);
/* Check to see if this is really gfs1 */
- if (sbd1->sb_fs_format == GFS_FORMAT_FS &&
- sbd1->sb_header.mh_type == GFS_METATYPE_SB &&
- sbd1->sb_header.mh_format == GFS_FORMAT_SB &&
- sbd1->sb_multihost_format == GFS_FORMAT_MULTI) {
- struct gfs_sb *sbbuf = (struct gfs_sb *)bh->b_data;
-
+ mh = (struct gfs2_meta_header *)bh->b_data;
+ if (sbd.sd_fs_format == GFS_FORMAT_FS &&
+ be32_to_cpu(mh->mh_type) == GFS_METATYPE_SB &&
+ be32_to_cpu(mh->mh_format) == GFS_FORMAT_SB &&
+ sbd.sd_multihost_format == GFS_FORMAT_MULTI) {
sbd.gfs1 = TRUE;
- sbd1->sb_flags = be32_to_cpu(sbbuf->sb_flags);
- sbd1->sb_seg_size = be32_to_cpu(sbbuf->sb_seg_size);
- gfs2_inum_in(&sbd1->sb_rindex_di, (void *)&sbbuf->sb_rindex_di);
- gfs2_inum_in(&gfs1_quota_di, (void *)&sbbuf->sb_quota_di);
- gfs2_inum_in(&gfs1_license_di, (void *)&sbbuf->sb_license_di);
}
else
sbd.gfs1 = FALSE;
- sbd.bsize = sbd.sd_sb.sb_bsize;
- if (!sbd.bsize)
- sbd.bsize = GFS2_DEFAULT_BSIZE;
+ if (!sbd.sd_bsize)
+ sbd.sd_bsize = GFS2_DEFAULT_BSIZE;
if (lgfs2_get_dev_info(fd, &sbd.dinfo)) {
perror(device);
exit(-1);
@@ -930,26 +924,25 @@ static void read_superblock(int fd)
fprintf(stderr, "Failed to compute constants.\n");
exit(-1);
}
- if (sbd.gfs1 || (sbd.sd_sb.sb_header.mh_magic == GFS2_MAGIC &&
- sbd.sd_sb.sb_header.mh_type == GFS2_METATYPE_SB))
- block = 0x10 * (GFS2_DEFAULT_BSIZE / sbd.bsize);
+ if (sbd.gfs1 || (be32_to_cpu(mh->mh_magic) == GFS2_MAGIC &&
+ be32_to_cpu(mh->mh_type) == GFS2_METATYPE_SB))
+ block = 0x10 * (GFS2_DEFAULT_BSIZE / sbd.sd_bsize);
else {
block = starting_blk = 0;
}
fix_device_geometry(&sbd);
if(sbd.gfs1) {
- sbd.sd_inptrs = (sbd.bsize - sizeof(struct gfs_indirect)) /
+ sbd.sd_inptrs = (sbd.sd_bsize - sizeof(struct gfs_indirect)) /
sizeof(uint64_t);
- sbd.sd_diptrs = (sbd.bsize - sizeof(struct gfs_dinode)) /
+ sbd.sd_diptrs = (sbd.sd_bsize - sizeof(struct gfs_dinode)) /
sizeof(uint64_t);
- sbd.md.riinode = lgfs2_inode_read(&sbd, sbd1->sb_rindex_di.no_addr);
+ sbd.md.riinode = lgfs2_inode_read(&sbd, sbd.sd_rindex_di.no_addr);
} else {
- sbd.sd_inptrs = (sbd.bsize - sizeof(struct gfs2_meta_header)) /
+ sbd.sd_inptrs = (sbd.sd_bsize - sizeof(struct gfs2_meta_header)) /
sizeof(uint64_t);
- sbd.sd_diptrs = (sbd.bsize - sizeof(struct gfs2_dinode)) /
+ sbd.sd_diptrs = (sbd.sd_bsize - sizeof(struct gfs2_dinode)) /
sizeof(uint64_t);
- sbd.master_dir = lgfs2_inode_read(&sbd,
- sbd.sd_sb.sb_master_dir.no_addr);
+ sbd.master_dir = lgfs2_inode_read(&sbd, sbd.sd_meta_dir.no_addr);
if (sbd.master_dir == NULL) {
sbd.md.riinode = NULL;
} else {
@@ -980,7 +973,7 @@ static int read_master_dir(void)
{
ioctl(sbd.device_fd, BLKFLSBUF, 0);
- bh = bread(&sbd, sbd.sd_sb.sb_master_dir.no_addr);
+ bh = bread(&sbd, sbd.sd_meta_dir.no_addr);
if (bh == NULL)
return 1;
di = (struct gfs2_dinode *)bh->b_data;
@@ -996,12 +989,12 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
if (block == RGLIST_DUMMY_BLOCK) {
if (sbd.gfs1)
- blk = sbd1->sb_rindex_di.no_addr;
+ blk = sbd.sd_rindex_di.no_addr;
else
blk = masterblock("rindex");
} else if (block == JOURNALS_DUMMY_BLOCK) {
if (sbd.gfs1)
- blk = sbd1->sb_jindex_di.no_addr;
+ blk = sbd.sd_jindex_di.no_addr;
else
blk = masterblock("jindex");
} else
@@ -1013,7 +1006,7 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
if (bh == NULL || bh->b_blocknr != blk) { /* If we changed blocks from the last read
*/
if (bh != NULL)
brelse(bh);
- dev_offset = blk * sbd.bsize;
+ dev_offset = blk * sbd.sd_bsize;
ioctl(sbd.device_fd, BLKFLSBUF, 0);
if (!(bh = bread(&sbd, blk))) {
fprintf(stderr, "read error: %s from %s:%d: "
@@ -1030,27 +1023,27 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
return 0;
indirect_blocks = 0;
lines_per_row[dmode] = 1;
- if (gfs2_struct_type == GFS2_METATYPE_SB || blk == 0x10 * (4096 / sbd.bsize)) {
- gfs2_sb_in(&sbd.sd_sb, bh->b_data);
+ if (gfs2_struct_type == GFS2_METATYPE_SB || blk == 0x10 * (4096 / sbd.sd_bsize)) {
+ lgfs2_sb_in(&sbd, bh->b_data);
memset(indirect, 0, sizeof(struct iinfo));
- indirect->ii[0].block = sbd.sd_sb.sb_master_dir.no_addr;
+ indirect->ii[0].block = sbd.sd_meta_dir.no_addr;
indirect->ii[0].is_dir = TRUE;
indirect->ii[0].dirents = 2;
memcpy(&indirect->ii[0].dirent[0].filename, "root", 4);
indirect->ii[0].dirent[0].dirent.de_inum.no_formal_ino =
- sbd.sd_sb.sb_root_dir.no_formal_ino;
+ sbd.sd_root_dir.no_formal_ino;
indirect->ii[0].dirent[0].dirent.de_inum.no_addr =
- sbd.sd_sb.sb_root_dir.no_addr;
- indirect->ii[0].dirent[0].block = sbd.sd_sb.sb_root_dir.no_addr;
+ sbd.sd_root_dir.no_addr;
+ indirect->ii[0].dirent[0].block = sbd.sd_root_dir.no_addr;
indirect->ii[0].dirent[0].dirent.de_type = DT_DIR;
memcpy(&indirect->ii[0].dirent[1].filename, "master", 7);
indirect->ii[0].dirent[1].dirent.de_inum.no_formal_ino =
- sbd.sd_sb.sb_master_dir.no_formal_ino;
+ sbd.sd_meta_dir.no_formal_ino;
indirect->ii[0].dirent[1].dirent.de_inum.no_addr =
- sbd.sd_sb.sb_master_dir.no_addr;
- indirect->ii[0].dirent[1].block = sbd.sd_sb.sb_master_dir.no_addr;
+ sbd.sd_meta_dir.no_addr;
+ indirect->ii[0].dirent[1].block = sbd.sd_meta_dir.no_addr;
indirect->ii[0].dirent[1].dirent.de_type = DT_DIR;
}
else if (gfs2_struct_type == GFS2_METATYPE_DI) {
@@ -1085,7 +1078,7 @@ int display(int identify_only, int trunc_zeros, uint64_t flagref,
move(line, 0);
}
if (dmode == HEX_MODE) { /* if hex display mode */
- uint64_t len = sbd.bsize;
+ uint64_t len = sbd.sd_bsize;
if (gfs2_struct_type == GFS2_METATYPE_DI)
len = struct_len + be64_to_cpu(di->di_size);
@@ -1164,7 +1157,7 @@ static uint64_t find_metablockoftype_slow(uint64_t startblk, int
metatype, int p
int found = 0;
struct gfs2_buffer_head *lbh;
- last_fs_block = lseek(sbd.device_fd, 0, SEEK_END) / sbd.bsize;
+ last_fs_block = lseek(sbd.device_fd, 0, SEEK_END) / sbd.sd_bsize;
for (blk = startblk + 1; blk < last_fs_block; blk++) {
lbh = bread(&sbd, blk);
/* Can't use get_block_type here (returns false "none") */
@@ -1197,7 +1190,7 @@ static int find_rg_metatype(struct rgrp_tree *rgd, uint64_t *blk,
uint64_t start
int found;
unsigned i, j, m;
struct gfs2_buffer_head *bhp = NULL;
- uint64_t *ibuf = malloc(sbd.bsize * GFS2_NBBY * sizeof(uint64_t));
+ uint64_t *ibuf = malloc(sbd.sd_bsize * GFS2_NBBY * sizeof(uint64_t));
for (i = 0; i < rgd->rt_length; i++) {
m = lgfs2_bm_scan(rgd, i, ibuf, GFS2_BLKST_DINODE);
@@ -1322,21 +1315,21 @@ uint64_t check_keywords(const char *kword)
unsigned long long blk = 0;
if (!strcmp(kword, "sb") ||!strcmp(kword, "superblock"))
- blk = 0x10 * (4096 / sbd.bsize); /* superblock */
+ blk = 0x10 * (4096 / sbd.sd_bsize); /* superblock */
else if (!strcmp(kword, "root") || !strcmp(kword, "rootdir"))
- blk = sbd.sd_sb.sb_root_dir.no_addr;
+ blk = sbd.sd_root_dir.no_addr;
else if (!strcmp(kword, "master")) {
if (sbd.gfs1)
fprintf(stderr, "This is GFS1; there's no master directory.\n");
- else if (!sbd.sd_sb.sb_master_dir.no_addr) {
+ else if (!sbd.sd_meta_dir.no_addr) {
fprintf(stderr, "GFS2 master directory not found on %s\n", device);
exit(-1);
} else
- blk = sbd.sd_sb.sb_master_dir.no_addr;
+ blk = sbd.sd_meta_dir.no_addr;
}
else if (!strcmp(kword, "jindex")) {
if (sbd.gfs1)
- blk = sbd1->sb_jindex_di.no_addr;
+ blk = sbd.sd_jindex_di.no_addr;
else
blk = masterblock("jindex"); /* journal index */
}
@@ -1352,7 +1345,7 @@ uint64_t check_keywords(const char *kword)
}
else if (!strcmp(kword, "rindex") || !strcmp(kword, "rgindex")) {
if (sbd.gfs1)
- blk = sbd1->sb_rindex_di.no_addr;
+ blk = sbd.sd_rindex_di.no_addr;
else
blk = masterblock("rindex");
} else if (!strcmp(kword, "rgs")) {
@@ -1448,7 +1441,7 @@ static void hex_edit(int *exitch)
int left_off;
int ch;
- left_off = ((block * sbd.bsize) < 0xffffffff) ? 9 : 17;
+ left_off = ((block * sbd.sd_bsize) < 0xffffffff) ? 9 : 17;
/* 8 and 16 char addresses on screen */
if (bobgets(estring, edit_row[HEX_MODE] + 3,
@@ -1480,8 +1473,8 @@ static void hex_edit(int *exitch)
ch += (estring[i+1] - 'A' + 0x0a);
bh->b_data[offset + hexoffset] = ch;
}
- if (pwrite(sbd.device_fd, bh->b_data, sbd.bsize, dev_offset) !=
- sbd.bsize) {
+ if (pwrite(sbd.device_fd, bh->b_data, sbd.sd_bsize, dev_offset) !=
+ sbd.sd_bsize) {
fprintf(stderr, "write error: %s from %s:%d: "
"offset %lld (0x%llx)\n",
strerror(errno),
@@ -1515,10 +1508,10 @@ static void pageup(void)
if (dmode == GFS2_MODE || offset==0) {
block--;
if (dmode == HEX_MODE)
- offset = (sbd.bsize % screen_chunk_size) > 0 ?
+ offset = (sbd.sd_bsize % screen_chunk_size) > 0 ?
screen_chunk_size *
- (sbd.bsize / screen_chunk_size) :
- sbd.bsize - screen_chunk_size;
+ (sbd.sd_bsize / screen_chunk_size) :
+ sbd.sd_bsize - screen_chunk_size;
else
offset = 0;
} else
@@ -1546,7 +1539,7 @@ static void pagedn(void)
else {
start_row[dmode] = edit_row[dmode] = 0;
if (dmode == GFS2_MODE ||
- offset + screen_chunk_size >= sbd.bsize) {
+ offset + screen_chunk_size >= sbd.sd_bsize) {
block++;
offset = 0;
} else
@@ -1844,7 +1837,7 @@ static void interactive_mode(void)
edit_row[dmode] = 0;
}
else {
- block = 0x10 * (4096 / sbd.bsize);
+ block = 0x10 * (4096 / sbd.sd_bsize);
push_block(block);
offset = 0;
}
@@ -2210,7 +2203,7 @@ static int count_dinode_bits(struct gfs2_buffer_head *rbh)
else
blk = sizeof(struct gfs2_meta_header);
- for (; blk < sbd.bsize; blk++) {
+ for (; blk < sbd.sd_bsize; blk++) {
byte = rbh->b_data + (blk / GFS2_NBBY);
bit = (blk % GFS2_NBBY) * GFS2_BIT_SIZE;
if (((*byte >> bit) & GFS2_BIT_MASK) == GFS2_BLKST_DINODE)
@@ -2255,7 +2248,7 @@ static void rg_repair(void)
if (gfs2_check_meta(rbh->b_data, mtype)) { /* wrong type */
printf("Damaged. Repairing...");
/* Fix the meta header */
- memset(rbh->b_data, 0, sbd.bsize);
+ memset(rbh->b_data, 0, sbd.sd_bsize);
mh = (struct gfs2_meta_header *)rbh->b_data;
mh->mh_magic = cpu_to_be32(GFS2_MAGIC);
mh->mh_type = cpu_to_be32(mtype);
@@ -2558,7 +2551,7 @@ int main(int argc, char *argv[])
memset(edit_size, 0, sizeof(edit_size));
memset(last_entry_onscreen, 0, sizeof(last_entry_onscreen));
dmode = INIT_MODE;
- sbd.bsize = 4096;
+ sbd.sd_bsize = 4096;
block = starting_blk = 0x10;
for (i = 0; i < BLOCK_STACK_SIZE; i++) {
blockstack[i].dmode = HEX_MODE;
@@ -2582,12 +2575,12 @@ int main(int argc, char *argv[])
fd = open(device, O_RDWR);
if (fd < 0)
die("can't open %s: %s\n", device, strerror(errno));
- max_block = lseek(fd, 0, SEEK_END) / sbd.bsize;
+ max_block = lseek(fd, 0, SEEK_END) / sbd.sd_bsize;
read_superblock(fd);
if (read_rindex())
exit(-1);
- max_block = lseek(fd, 0, SEEK_END) / sbd.bsize;
+ max_block = lseek(fd, 0, SEEK_END) / sbd.sd_bsize;
if (sbd.gfs1)
edit_row[GFS2_MODE]++;
else if (read_master_dir() != 0)
@@ -2595,7 +2588,7 @@ int main(int argc, char *argv[])
process_parameters(argc, argv, 1); /* get what to print from cmdline */
- block = blockstack[0].block = starting_blk * (4096 / sbd.bsize);
+ block = blockstack[0].block = starting_blk * (4096 / sbd.sd_bsize);
if (termlines)
interactive_mode();
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index b0ca1fba..fb060089 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -46,7 +46,6 @@ extern int start_row[DMODES], end_row[DMODES], lines_per_row[DMODES];
extern int edit_size[DMODES], last_entry_onscreen[DMODES];
extern char edit_fmt[80];
extern struct gfs2_sbd sbd;
-extern struct gfs_sb *sbd1;
extern struct gfs2_inum gfs1_quota_di; /* kludge because gfs2 sb too small */
extern struct gfs2_inum gfs1_license_di; /* kludge because gfs2 sb too small */
extern struct gfs2_dinode *di;
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index 0da00235..eb8fb4f6 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -38,7 +38,7 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size)
uint64_t jindex_block, jblock = 0;
int amtread;
struct gfs2_buffer_head *jindex_bh, *j_bh;
- char jbuf[sbd.bsize];
+ char jbuf[sbd.sd_bsize];
journal_num = atoi(journal + 7);
if (journal_num < 0)
@@ -46,7 +46,7 @@ uint64_t find_journal_block(const char *journal, uint64_t *j_size)
/* Figure out the block of the jindex file */
if (sbd.gfs1)
- jindex_block = sbd1->sb_jindex_di.no_addr;
+ jindex_block = sbd.sd_jindex_di.no_addr;
else
jindex_block = masterblock("jindex");
/* read in the block */
@@ -134,8 +134,8 @@ static int fsck_readi(struct gfs2_inode *ip, void *rbuf, uint64_t
roffset,
o = roffset % sdp->sd_jbsize;
lblock = roffset / sdp->sd_jbsize;
} else {
- lblock = roffset >> sdp->sd_sb.sb_bsize_shift;
- o = roffset & (sdp->bsize - 1);
+ lblock = roffset >> sdp->sd_bsize_shift;
+ o = roffset & (sdp->sd_bsize - 1);
}
if (!ip->i_height) /* inode_is_stuffed */
@@ -145,8 +145,8 @@ static int fsck_readi(struct gfs2_inode *ip, void *rbuf, uint64_t
roffset,
while (copied < size) {
amount = size - copied;
- if (amount > sdp->bsize - o)
- amount = sdp->bsize - o;
+ if (amount > sdp->sd_bsize - o)
+ amount = sdp->sd_bsize - o;
if (!extlen)
block_map(ip, lblock, ¬_new, &dblock, &extlen,
FALSE);
@@ -331,7 +331,7 @@ static uint64_t find_wrap_pt(struct gfs2_inode *ji, char *jbuf,
uint64_t jblock,
uint64_t jb = 0;
uint64_t highest_seq = 0;
- for (jb = 0; jb < j_size; jb += (sbd.gfs1 ? 1 : sbd.bsize)) {
+ for (jb = 0; jb < j_size; jb += (sbd.gfs1 ? 1 : sbd.sd_bsize)) {
int found = 0;
if (sbd.gfs1) {
@@ -344,7 +344,7 @@ static uint64_t find_wrap_pt(struct gfs2_inode *ji, char *jbuf,
uint64_t jblock,
int copied;
uint64_t abs_block;
- copied = fsck_readi(ji, jbuf, jb, sbd.bsize, &abs_block);
+ copied = fsck_readi(ji, jbuf, jb, sbd.sd_bsize, &abs_block);
if (!copied) /* end of file */
break;
found = is_wrap_pt(jbuf, &highest_seq);
@@ -385,11 +385,11 @@ static int process_ld(uint64_t abs_block, uint64_t wrappt, uint64_t
j_size,
b = (uint64_t *)(buf + sizeof(struct gfs_log_descriptor));
else
b = (uint64_t *)(buf + sizeof(struct gfs2_log_descriptor));
- *prnt = ld_is_pertinent(b, (buf + sbd.bsize), tblk, rgd, bitblk);
+ *prnt = ld_is_pertinent(b, (buf + sbd.sd_bsize), tblk, rgd, bitblk);
if (*prnt) {
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log descriptor,
",
- abs_block, ((jb + wrappt) % j_size) / sbd.bsize);
+ abs_block, ((jb + wrappt) % j_size) / sbd.sd_bsize);
print_gfs2("type %"PRIu32" ", ld_type);
for (ltndx = 0;; ltndx++) {
@@ -406,7 +406,7 @@ static int process_ld(uint64_t abs_block, uint64_t wrappt, uint64_t
j_size,
if (ld_type == GFS2_LOG_DESC_METADATA ||
ld_type == GFS_LOG_DESC_METADATA)
is_meta_ld = 1;
- ld_blocks -= print_ld_blks(b, (buf + sbd.bsize), line, tblk, tblk_off,
+ ld_blocks -= print_ld_blks(b, (buf + sbd.sd_bsize), line, tblk, tblk_off,
bitblk, rgd, abs_block, *prnt, bblk_off,
is_meta_ld);
@@ -435,7 +435,7 @@ static int meta_has_ref(uint64_t abs_block, int tblk)
}
}
b = (uint64_t *)(mbh->b_data + structlen);
- while (!has_ref && mtype && (char *)b < mbh->b_data + sbd.bsize)
{
+ while (!has_ref && mtype && (char *)b < mbh->b_data +
sbd.sd_bsize) {
if (be64_to_cpu(*b) == tblk)
has_ref = 1;
b++;
@@ -492,7 +492,7 @@ static void display_log_header(void *buf, uint64_t *highest_seq,
uint64_t abs_bl
} else {
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: Seq:
0x%"PRIx64", "
"tail: 0x%"PRIx32", blk: 0x%"PRIx32" [%s]",
- abs_block, (jb % j_size) / sbd.bsize, be64_to_cpu(lh->lh_sequence),
+ abs_block, (jb % j_size) / sbd.sd_bsize, be64_to_cpu(lh->lh_sequence),
be32_to_cpu(lh->lh_tail), be32_to_cpu(lh->lh_blkno), flags_str);
}
}
@@ -544,7 +544,7 @@ void dump_journal(const char *journal, int tblk)
fprintf(stderr, "Out of memory\n");
exit(-1);
}
- jbuf = malloc(sbd.bsize);
+ jbuf = malloc(sbd.sd_bsize);
if (jbuf == NULL) {
fprintf(stderr, "Out of memory\n");
exit(-1);
@@ -578,7 +578,7 @@ void dump_journal(const char *journal, int tblk)
}
wrappt = find_wrap_pt(j_inode, jbuf, jblock, j_size);
- wp = wrappt / (sbd.gfs1 ? 1 : sbd.bsize);
+ wp = wrappt / (sbd.gfs1 ? 1 : sbd.sd_bsize);
print_gfs2("Starting at journal wrap block: 0x%llx "
"(j + 0x%llx)",
(unsigned long long)jblock + wp,
@@ -586,7 +586,7 @@ void dump_journal(const char *journal, int tblk)
eol(0);
}
- for (jb = 0; jb < j_size; jb += (sbd.gfs1 ? 1 : sbd.bsize)) {
+ for (jb = 0; jb < j_size; jb += (sbd.gfs1 ? 1 : sbd.sd_bsize)) {
int is_pertinent = 1;
uint32_t block_type = 0;
@@ -599,7 +599,7 @@ void dump_journal(const char *journal, int tblk)
} else {
int error = fsck_readi(j_inode, (void *)jbuf,
((jb + wrappt) % j_size),
- sbd.bsize, &abs_block);
+ sbd.sd_bsize, &abs_block);
if (!error) /* end of file */
break;
buf = jbuf;
@@ -625,10 +625,10 @@ void dump_journal(const char *journal, int tblk)
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log descriptor"
" continuation block", abs_block,
- ((jb + wrappt) % j_size) / sbd.bsize);
+ ((jb + wrappt) % j_size) / sbd.sd_bsize);
eol(0);
print_gfs2(" ");
- ld_blocks -= print_ld_blks(b, (buf + sbd.bsize), start_line,
+ ld_blocks -= print_ld_blks(b, (buf + sbd.sd_bsize), start_line,
tblk, &tblk_off, 0, rgd, 0, 1, NULL, 0);
} else if (block_type == 0) {
continue;
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index e55b66f6..b4706248 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -311,7 +311,7 @@ static size_t di_save_len(const char *buf, uint64_t owner)
indirect pointers, dirents, symlinks or fs internal data */
if (di_height > 0 || S_ISDIR(di_mode) || S_ISLNK(di_mode) || gfs1dir
|| block_is_systemfile(owner))
- return sbd.bsize;
+ return sbd.sd_bsize;
return sizeof(struct gfs2_dinode);
}
@@ -335,7 +335,7 @@ static int get_gfs_struct_info(const char *buf, uint64_t owner,
unsigned *block_
*block_type = 0;
if (gstruct_len != NULL)
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
gfs2_meta_header_in(&mh, buf);
if (mh.mh_magic != GFS2_MAGIC)
@@ -355,22 +355,22 @@ static int get_gfs_struct_info(const char *buf, uint64_t owner,
unsigned *block_
*gstruct_len = sizeof(struct gfs2_sb);
break;
case GFS2_METATYPE_RG: /* 2 (rsrc grp hdr) */
- *gstruct_len = sbd.bsize; /*sizeof(struct gfs_rgrp);*/
+ *gstruct_len = sbd.sd_bsize; /*sizeof(struct gfs_rgrp);*/
break;
case GFS2_METATYPE_RB: /* 3 (rsrc grp bitblk) */
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
case GFS2_METATYPE_DI: /* 4 (disk inode) */
*gstruct_len = di_save_len(buf, owner);
break;
case GFS2_METATYPE_IN: /* 5 (indir inode blklst) */
- *gstruct_len = sbd.bsize; /*sizeof(struct gfs_indirect);*/
+ *gstruct_len = sbd.sd_bsize; /*sizeof(struct gfs_indirect);*/
break;
case GFS2_METATYPE_LF: /* 6 (leaf dinode blklst) */
- *gstruct_len = sbd.bsize; /*sizeof(struct gfs_leaf);*/
+ *gstruct_len = sbd.sd_bsize; /*sizeof(struct gfs_leaf);*/
break;
case GFS2_METATYPE_JD: /* 7 (journal data) */
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
case GFS2_METATYPE_LH: /* 8 (log header) */
if (sbd.gfs1)
@@ -382,16 +382,16 @@ static int get_gfs_struct_info(const char *buf, uint64_t owner,
unsigned *block_
*gstruct_len = sizeof(struct gfs2_log_header);
break;
case GFS2_METATYPE_LD: /* 9 (log descriptor) */
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
case GFS2_METATYPE_EA: /* 10 (extended attr hdr) */
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
case GFS2_METATYPE_ED: /* 11 (extended attr data) */
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
default:
- *gstruct_len = sbd.bsize;
+ *gstruct_len = sbd.sd_bsize;
break;
}
return 0;
@@ -571,12 +571,12 @@ struct block_range {
static int block_range_prepare(struct block_range *br)
{
- br->buf = calloc(br->len, sbd.bsize + sizeof(*br->blktype) +
sizeof(*br->blklen));
+ br->buf = calloc(br->len, sbd.sd_bsize + sizeof(*br->blktype) +
sizeof(*br->blklen));
if (br->buf == NULL) {
perror("Failed to allocate block range buffer");
return 1;
}
- br->blktype = (unsigned *)(br->buf + (br->len * sbd.bsize));
+ br->blktype = (unsigned *)(br->buf + (br->len * sbd.sd_bsize));
br->blklen = br->blktype + br->len;
return 0;
}
@@ -596,7 +596,7 @@ static int block_range_check(struct block_range *br)
static void block_range_setinfo(struct block_range *br, uint64_t owner)
{
for (unsigned i = 0; i < br->len; i++) {
- char *buf = br->buf + (i * sbd.bsize);
+ char *buf = br->buf + (i * sbd.sd_bsize);
uint64_t addr = br->start + i;
uint64_t _owner = (owner == 0) ? addr : owner;
@@ -644,7 +644,7 @@ static int save_range(struct metafd *mfd, struct block_range *br)
for (unsigned i = 0; i < br->len; i++) {
int err;
- err = save_buf(mfd, br->buf + (i * sbd.bsize), br->start + i, br->blklen[i]);
+ err = save_buf(mfd, br->buf + (i * sbd.sd_bsize), br->start + i,
br->blklen[i]);
if (err != 0)
return err;
}
@@ -661,8 +661,8 @@ static int check_read_range(int fd, struct block_range *br, uint64_t
owner)
if (block_range_check(br) != 0)
return 1;
- size = br->len * sbd.bsize;
- if (pread(sbd.device_fd, br->buf, size, sbd.bsize * br->start) != size) {
+ size = br->len * sbd.sd_bsize;
+ if (pread(sbd.device_fd, br->buf, size, sbd.sd_bsize * br->start) != size) {
fprintf(stderr, "Failed to read block range 0x%"PRIx64" (%u blocks):
%s\n",
br->start, br->len, strerror(errno));
free(br->buf);
@@ -698,7 +698,7 @@ static void save_ea_block(struct metafd *mfd, char *buf, uint64_t
owner)
uint32_t rec_len = 0;
int e;
- for (e = sizeof(struct gfs2_meta_header); e < sbd.bsize; e += rec_len) {
+ for (e = sizeof(struct gfs2_meta_header); e < sbd.sd_bsize; e += rec_len) {
uint64_t blk, *b;
int charoff, i;
@@ -716,7 +716,7 @@ static void save_ea_block(struct metafd *mfd, char *buf, uint64_t
owner)
blk = be64_to_cpu(*b);
_buf = check_read_block(sbd.device_fd, blk, owner, NULL, NULL);
if (_buf != NULL) {
- save_buf(mfd, _buf, blk, sbd.bsize);
+ save_buf(mfd, _buf, blk, sbd.sd_bsize);
free(_buf);
}
}
@@ -737,7 +737,7 @@ static void save_indirect_range(struct metafd *mfd, struct block_range
**brp, ui
save_range(mfd, br);
for (unsigned i = 0; i < br->len; i++) {
if (br->blktype[i] == GFS2_METATYPE_EA)
- save_ea_block(mfd, br->buf + (i * sbd.bsize), owner);
+ save_ea_block(mfd, br->buf + (i * sbd.sd_bsize), owner);
}
if (q) {
block_range_queue_insert(q, br);
@@ -756,7 +756,7 @@ static void save_indirect_blocks(struct metafd *mfd, char *buf,
uint64_t owner,
uint64_t *ptr;
for (ptr = (uint64_t *)(buf + headsize);
- (char *)ptr < (buf + sbd.bsize); ptr++) {
+ (char *)ptr < (buf + sbd.sd_bsize); ptr++) {
if (!*ptr)
continue;
@@ -802,8 +802,8 @@ static int save_leaf_chain(struct metafd *mfd, struct gfs2_sbd *sdp,
char *buf)
if (gfs2_check_range(sdp, blk) != 0)
return 0;
- r = pread(sdp->device_fd, buf, sdp->bsize, sdp->bsize * blk);
- if (r != sdp->bsize) {
+ r = pread(sdp->device_fd, buf, sdp->sd_bsize, sdp->sd_bsize * blk);
+ if (r != sdp->sd_bsize) {
fprintf(stderr, "Failed to read leaf block %"PRIx64": %s\n",
blk, strerror(errno));
free(buf);
@@ -811,7 +811,7 @@ static int save_leaf_chain(struct metafd *mfd, struct gfs2_sbd *sdp,
char *buf)
}
report_progress(blk, 0);
if (gfs2_check_meta(buf, GFS2_METATYPE_LF) == 0) {
- int ret = save_buf(mfd, buf, blk, sdp->bsize);
+ int ret = save_buf(mfd, buf, blk, sdp->sd_bsize);
if (ret != 0) {
free(buf);
return ret;
@@ -828,7 +828,7 @@ static void save_leaf_blocks(struct metafd *mfd, struct
block_range_queue *q)
struct block_range *br = q->tail;
for (unsigned i = 0; i < br->len; i++) {
- char *buf = br->buf + (i * sbd.bsize);
+ char *buf = br->buf + (i * sbd.sd_bsize);
save_leaf_chain(mfd, &sbd, buf);
}
@@ -896,7 +896,7 @@ static void save_inode_data(struct metafd *mfd, char *ibuf, uint64_t
iblk)
struct block_range *q = block_range_queue_pop(&indq[i - 1]);
for (unsigned j = 0; j < q->len; j++) {
- char *_buf = q->buf + (j * sbd.bsize);
+ char *_buf = q->buf + (j * sbd.sd_bsize);
save_indirect_blocks(mfd, _buf, iblk, nextq, sizeof(dip->di_header));
}
@@ -949,8 +949,7 @@ static void get_journal_inode_blocks(void)
struct gfs_jindex ji;
char jbuf[sizeof(struct gfs_jindex)];
- j_inode = lgfs2_gfs_inode_read(&sbd,
- sbd1->sb_jindex_di.no_addr);
+ j_inode = lgfs2_gfs_inode_read(&sbd, sbd.sd_jindex_di.no_addr);
if (j_inode == NULL) {
fprintf(stderr, "Error reading journal inode: %s\n", strerror(errno));
return;
@@ -980,7 +979,7 @@ static void save_allocated_range(struct metafd *mfd, struct
block_range *br)
save_range(mfd, br);
for (unsigned i = 0; i < br->len; i++) {
- char *buf = br->buf + (i * sbd.bsize);
+ char *buf = br->buf + (i * sbd.sd_bsize);
if (br->blktype[i] == GFS2_METATYPE_DI)
save_inode_data(mfd, buf, br->start + i);
@@ -992,7 +991,7 @@ static void save_allocated(struct rgrp_tree *rgd, struct metafd *mfd)
{
uint64_t blk = 0;
unsigned i, j, m;
- uint64_t *ibuf = malloc(sbd.bsize * GFS2_NBBY * sizeof(uint64_t));
+ uint64_t *ibuf = malloc(sbd.sd_bsize * GFS2_NBBY * sizeof(uint64_t));
for (i = 0; i < rgd->rt_length; i++) {
struct block_range br = {0};
@@ -1036,8 +1035,8 @@ static void save_allocated(struct rgrp_tree *rgd, struct metafd
*mfd)
static char *rgrp_read(struct gfs2_sbd *sdp, uint64_t addr, unsigned blocks)
{
- size_t len = blocks * sdp->bsize;
- off_t off = addr * sdp->bsize;
+ size_t len = blocks * sdp->sd_bsize;
+ off_t off = addr * sdp->sd_bsize;
char *buf;
if (blocks == 0 || gfs2_check_range(sdp, addr))
@@ -1064,13 +1063,13 @@ static void save_rgrp(struct gfs2_sbd *sdp, struct metafd *mfd,
struct rgrp_tree
return;
for (unsigned i = 0; i < rgd->rt_length; i++)
- rgd->bits[i].bi_data = buf + (i * sdp->bsize);
+ rgd->bits[i].bi_data = buf + (i * sdp->sd_bsize);
log_debug("RG at %"PRIu64" is %"PRIu32" long\n", addr,
rgd->rt_length);
/* Save the rg and bitmaps */
for (unsigned i = 0; i < rgd->rt_length; i++) {
report_progress(rgd->rt_addr + i, 0);
- save_buf(mfd, buf + (i * sdp->bsize), rgd->rt_addr + i, sdp->bsize);
+ save_buf(mfd, buf + (i * sdp->sd_bsize), rgd->rt_addr + i, sdp->sd_bsize);
}
/* Save the other metadata: inodes, etc. if mode is not 'savergs' */
if (withcontents)
@@ -1130,11 +1129,11 @@ void savemeta(char *out_fn, int saveoption, int gziplevel)
blks_saved = 0;
if (sbd.gfs1)
- sbd.bsize = sbd.sd_sb.sb_bsize;
+ sbd.sd_bsize = sbd.sd_bsize;
printf("There are %llu blocks of %u bytes in the filesystem.\n",
- (unsigned long long)sbd.fssize, sbd.bsize);
+ (unsigned long long)sbd.fssize, sbd.sd_bsize);
- printf("Filesystem size: %.2fGB\n", (sbd.fssize * sbd.bsize) / ((float)(1
<< 30)));
+ printf("Filesystem size: %.2fGB\n", (sbd.fssize * sbd.sd_bsize) / ((float)(1
<< 30)));
get_journal_inode_blocks();
err = init_per_node_lookup();
@@ -1142,13 +1141,13 @@ void savemeta(char *out_fn, int saveoption, int gziplevel)
exit(1);
/* Write the savemeta file header */
- err = save_header(&mfd, sbd.fssize * sbd.bsize);
+ err = save_header(&mfd, sbd.fssize * sbd.sd_bsize);
if (err) {
perror("Failed to write metadata file header");
exit(1);
}
/* Save off the superblock */
- sb_addr = GFS2_SB_ADDR * GFS2_BASIC_BLOCK / sbd.bsize;
+ sb_addr = GFS2_SB_ADDR * GFS2_BASIC_BLOCK / sbd.sd_bsize;
buf = check_read_block(sbd.device_fd, sb_addr, 0, NULL, NULL);
if (buf != NULL) {
if (sbd.gfs1)
@@ -1163,10 +1162,10 @@ void savemeta(char *out_fn, int saveoption, int gziplevel)
uint64_t blk;
int j;
- blk = sbd1->sb_rindex_di.no_addr;
+ blk = sbd.sd_rindex_di.no_addr;
buf = check_read_block(sbd.device_fd, blk, blk, NULL, NULL);
if (buf != NULL) {
- save_buf(&mfd, buf, blk, sbd.bsize);
+ save_buf(&mfd, buf, blk, sbd.sd_bsize);
save_inode_data(&mfd, buf, blk);
free(buf);
}
@@ -1230,7 +1229,7 @@ static char *restore_block(struct metafd *mfd, struct
saved_metablock *svb)
return NULL;
}
- if (svb->siglen > sbd.bsize) {
+ if (svb->siglen > sbd.sd_bsize) {
fprintf(stderr, "Bad record length: %u for block %"PRIu64"
(0x%"PRIx64").\n",
svb->siglen, svb->blk, svb->blk);
return NULL;
@@ -1252,17 +1251,16 @@ static int restore_super(struct metafd *mfd, void *buf, int
printonly)
{
int ret;
- gfs2_sb_in(&sbd.sd_sb, buf);
- sbd1 = (struct gfs_sb *)&sbd.sd_sb;
- ret = check_sb(&sbd.sd_sb);
+ lgfs2_sb_in(&sbd, buf);
+ ret = check_sb(buf);
if (ret < 0) {
fprintf(stderr, "Error: Invalid superblock in metadata file.\n");
return -1;
}
if (ret == 1)
sbd.gfs1 = 1;
- sbd.bsize = sbd.sd_sb.sb_bsize;
- if ((!printonly) && lgfs2_sb_write(&sbd.sd_sb, sbd.device_fd, sbd.bsize)) {
+ sbd.sd_bsize = sbd.sd_bsize;
+ if ((!printonly) && lgfs2_sb_write(&sbd, sbd.device_fd)) {
fprintf(stderr, "Failed to write superblock\n");
return -1;
}
@@ -1276,7 +1274,7 @@ static int restore_data(int fd, struct metafd *mfd, int printonly)
uint64_t writes = 0;
char *buf;
- buf = calloc(1, sbd.bsize);
+ buf = calloc(1, sbd.sd_bsize);
if (buf == NULL) {
perror("Failed to restore data");
exit(1);
@@ -1304,8 +1302,8 @@ static int restore_data(int fd, struct metafd *mfd, int printonly)
} else {
report_progress(savedata.blk, 0);
memcpy(buf, bp, savedata.siglen);
- memset(buf + savedata.siglen, 0, sbd.bsize - savedata.siglen);
- if (pwrite(fd, buf, sbd.bsize, savedata.blk * sbd.bsize) != sbd.bsize) {
+ memset(buf + savedata.siglen, 0, sbd.sd_bsize - savedata.siglen);
+ if (pwrite(fd, buf, sbd.sd_bsize, savedata.blk * sbd.sd_bsize) != sbd.sd_bsize) {
fprintf(stderr, "write error: %s from %s:%d: block %lld (0x%llx)\n",
strerror(errno), __FUNCTION__, __LINE__,
(unsigned long long)savedata.blk,
@@ -1388,11 +1386,11 @@ static int restore_init(const char *path, struct metafd *mfd,
struct savemeta_he
return ret;
if (smh->sh_fs_bytes > 0) {
- sbd.fssize = smh->sh_fs_bytes / sbd.bsize;
+ sbd.fssize = smh->sh_fs_bytes / sbd.sd_bsize;
printf("Saved file system size is %"PRIu64" blocks, %.2fGB\n",
sbd.fssize, smh->sh_fs_bytes / ((float)(1 << 30)));
}
- printf("Block size is %uB\n", sbd.bsize);
+ printf("Block size is %uB\n", sbd.sd_bsize);
printf("This is gfs%c metadata.\n", sbd.gfs1 ? '1': '2');
if (printonly > 1 && printonly == LGFS2_SB_ADDR(&sbd)) {
display_block_type(bp, LGFS2_SB_ADDR(&sbd), TRUE);
@@ -1433,7 +1431,7 @@ void restoremeta(const char *in_fn, const char *out_device, uint64_t
printonly)
exit(error);
if (!printonly) {
- uint64_t space = lseek(sbd.device_fd, 0, SEEK_END) / sbd.bsize;
+ uint64_t space = lseek(sbd.device_fd, 0, SEEK_END) / sbd.sd_bsize;
printf("There are %"PRIu64" free blocks on the destination
device.\n", space);
}
diff --git a/gfs2/fsck/afterpass1_common.c b/gfs2/fsck/afterpass1_common.c
index 35029202..301986f0 100644
--- a/gfs2/fsck/afterpass1_common.c
+++ b/gfs2/fsck/afterpass1_common.c
@@ -268,7 +268,7 @@ int delete_eattr_entry(struct gfs2_inode *ip, struct gfs2_buffer_head
*leaf_bh,
if (!ea_hdr->ea_num_ptrs)
return 0;
- avail_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
+ avail_size = sdp->sd_bsize - sizeof(struct gfs2_meta_header);
max_ptrs = (be32_to_cpu(ea_hdr->ea_data_len) + avail_size - 1) /
avail_size;
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index 7afec319..e9d3c849 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -107,7 +107,7 @@ static void refresh_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
if (rgd->rt_addr + i != blkno)
continue;
- memcpy(rgd->bits[i].bi_data, bh->b_data, sdp->bsize);
+ memcpy(rgd->bits[i].bi_data, bh->b_data, sdp->sd_bsize);
rgd->bits[i].bi_modified = 1;
if (i == 0) { /* this is the rgrp itself */
if (sdp->gfs1)
@@ -158,7 +158,7 @@ static int buf_lo_scan_elements(struct gfs2_inode *ip, unsigned int
start,
log_err(_("Out of memory when replaying journals.\n"));
return FSCK_ERROR;
}
- memcpy(bh_ip->b_data, bh_log->b_data, sdp->bsize);
+ memcpy(bh_ip->b_data, bh_log->b_data, sdp->sd_bsize);
check_magic = ((struct gfs2_meta_header *)
(bh_ip->b_data))->mh_magic;
@@ -213,7 +213,7 @@ static int revoke_lo_scan_elements(struct gfs2_inode *ip, unsigned int
start,
if (gfs2_check_meta(bh->b_data, GFS2_METATYPE_LB))
continue;
}
- while (offset + sizeof(uint64_t) <= sdp->sd_sb.sb_bsize) {
+ while (offset + sizeof(uint64_t) <= sdp->sd_bsize) {
blkno = be64_to_cpu(*(__be64 *)(bh->b_data + offset));
log_info( _("Journal replay processing revoke for "
"block #%lld (0x%llx) for journal+0x%x\n"),
@@ -278,7 +278,7 @@ static int databuf_lo_scan_elements(struct gfs2_inode *ip, unsigned
int start,
log_err(_("Out of memory when replaying journals.\n"));
return FSCK_ERROR;
}
- memcpy(bh_ip->b_data, bh_log->b_data, sdp->bsize);
+ memcpy(bh_ip->b_data, bh_log->b_data, sdp->sd_bsize);
/* Unescape */
if (esc) {
@@ -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_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_bsize;
uint32_t blk;
struct lgfs2_log_header lh;
uint64_t highest_seq = 0, lowest_seq = 0, prev_seq = 0;
@@ -467,7 +467,7 @@ int preen_is_safe(struct gfs2_sbd *sdp, int preen, int force_check)
return 1; /* not called by rc.sysinit--we're okay to preen */
if (force_check) /* If check was forced by the user? */
return 1; /* user's responsibility--we're okay to preen */
- if (!memcmp(sdp->sd_sb.sb_lockproto + 5, "nolock", 6))
+ if (!memcmp(sdp->sd_lockproto + 5, "nolock", 6))
return 1; /* local file system--preen is okay */
return 0; /* might be mounted on another node--not guaranteed safe */
}
@@ -608,9 +608,9 @@ out:
log_err( _("jid=%u: Failed\n"), j);
reinit:
if (query( _("Do you want to clear the journal instead? (y/n)"))) {
- error = write_journal(sdp->md.journal[j], sdp->bsize,
+ error = write_journal(sdp->md.journal[j], sdp->sd_bsize,
sdp->md.journal[j]->i_size /
- sdp->sd_sb.sb_bsize);
+ sdp->sd_bsize);
log_err(_("jid=%u: journal was cleared.\n"), j);
} else {
log_err( _("jid=%u: journal not cleared.\n"), j);
@@ -873,7 +873,7 @@ int init_jindex(struct gfs2_sbd *sdp, int allow_ji_rebuild)
/* rgrepair requires the journals be read in in order to distinguish
"real" rgrps from rgrps that are just copies left in journals. */
if (sdp->gfs1)
- sdp->md.jiinode = lgfs2_inode_read(sdp, sbd1->sb_jindex_di.no_addr);
+ sdp->md.jiinode = lgfs2_inode_read(sdp, sdp->sd_jindex_di.no_addr);
else
gfs2_lookupi(sdp->master_dir, "jindex", 6, &sdp->md.jiinode);
diff --git a/gfs2/fsck/fsck.h b/gfs2/fsck/fsck.h
index 8b7ac0a9..bc706860 100644
--- a/gfs2/fsck/fsck.h
+++ b/gfs2/fsck/fsck.h
@@ -157,7 +157,6 @@ extern struct osi_root inodetree;
extern int dups_found; /* How many duplicate references have we found? */
extern int dups_found_first; /* How many duplicates have we found the original
reference for? */
-extern struct gfs_sb *sbd1;
static inline int valid_block(struct gfs2_sbd *sdp, uint64_t blkno)
{
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index 16cc1b49..35599fb4 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -46,22 +46,22 @@ static int block_mounters(struct gfs2_sbd *sdp, int block_em)
{
if (block_em) {
/* verify it starts with lock_ */
- if (!strncmp(sdp->sd_sb.sb_lockproto, "lock_", 5)) {
+ if (!strncmp(sdp->sd_lockproto, "lock_", 5)) {
/* Change lock_ to fsck_ */
- memcpy(sdp->sd_sb.sb_lockproto, "fsck_", 5);
+ memcpy(sdp->sd_lockproto, "fsck_", 5);
}
/* FIXME: Need to do other verification in the else
* case */
} else {
/* verify it starts with fsck_ */
/* verify it starts with lock_ */
- if (!strncmp(sdp->sd_sb.sb_lockproto, "fsck_", 5)) {
+ if (!strncmp(sdp->sd_lockproto, "fsck_", 5)) {
/* Change fsck_ to lock_ */
- memcpy(sdp->sd_sb.sb_lockproto, "lock_", 5);
+ memcpy(sdp->sd_lockproto, "lock_", 5);
}
}
- if (lgfs2_sb_write(&sdp->sd_sb, sdp->device_fd, sdp->bsize)) {
+ if (lgfs2_sb_write(sdp, sdp->device_fd)) {
stack;
return -1;
}
@@ -134,7 +134,7 @@ static int set_block_ranges(struct gfs2_sbd *sdp)
{
struct osi_node *n, *next = NULL;
struct rgrp_tree *rgd;
- char buf[sdp->sd_sb.sb_bsize];
+ char buf[sdp->sd_bsize];
uint64_t rmax = 0;
uint64_t rmin = 0;
int error;
@@ -163,16 +163,16 @@ static int set_block_ranges(struct gfs2_sbd *sdp)
last_data_block = rmax;
first_data_block = rmin;
- if (fsck_lseek(sdp->device_fd, (last_fs_block * sdp->sd_sb.sb_bsize))){
+ if (fsck_lseek(sdp->device_fd, (last_fs_block * sdp->sd_bsize))){
log_crit( _("Can't seek to last block in file system: %llu"
" (0x%llx)\n"), (unsigned long long)last_fs_block,
(unsigned long long)last_fs_block);
goto fail;
}
- memset(buf, 0, sdp->sd_sb.sb_bsize);
- error = read(sdp->device_fd, buf, sdp->sd_sb.sb_bsize);
- if (error != sdp->sd_sb.sb_bsize){
+ memset(buf, 0, sdp->sd_bsize);
+ error = read(sdp->device_fd, buf, sdp->sd_bsize);
+ if (error != sdp->sd_bsize){
log_crit( _("Can't read last block in file system (error %u), "
"last_fs_block: %llu (0x%llx)\n"), error,
(unsigned long long)last_fs_block,
@@ -212,10 +212,10 @@ static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd,
/* Count up the free blocks in the bitmap */
off = (rgb) ? sizeof(struct gfs2_meta_header) :
sizeof(struct gfs2_rgrp);
- if (total_bytes_to_check <= sdp->bsize - off)
+ if (total_bytes_to_check <= sdp->sd_bsize - off)
bytes_to_check = total_bytes_to_check;
else
- bytes_to_check = sdp->bsize - off;
+ bytes_to_check = sdp->sd_bsize - off;
total_bytes_to_check -= bytes_to_check;
for (x = 0; x < bytes_to_check; x++) {
unsigned char *byte;
@@ -464,7 +464,7 @@ static int rebuild_master(struct gfs2_sbd *sdp)
}
log_err(_("Trying to rebuild the master directory.\n"));
inum.no_formal_ino = sdp->md.next_inum++;
- inum.no_addr = sdp->sd_sb.sb_master_dir.no_addr;
+ inum.no_addr = sdp->sd_meta_dir.no_addr;
err = init_dinode(sdp, &bh, &inum, S_IFDIR | 0755, GFS2_DIF_SYSTEM, &inum);
if (err != 0)
return -1;
@@ -651,8 +651,8 @@ static unsigned gfs2_rgrp_reada(struct gfs2_sbd *sdp, unsigned
cur_window,
if (i < cur_window)
continue;
rgd = (struct rgrp_tree *)n;
- start = rgd->rt_addr * sdp->bsize;
- len = rgd->rt_length * sdp->bsize;
+ start = rgd->rt_addr * sdp->sd_bsize;
+ len = rgd->rt_length * sdp->sd_bsize;
posix_fadvise(sdp->device_fd, start, len, POSIX_FADV_WILLNEED);
}
@@ -800,7 +800,7 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
log_info( _("Initializing special inodes...\n"));
/* Get root dinode */
- sdp->md.rooti = lgfs2_inode_read(sdp, sdp->sd_sb.sb_root_dir.no_addr);
+ sdp->md.rooti = lgfs2_inode_read(sdp, sdp->sd_root_dir.no_addr);
if (sdp->md.rooti == NULL)
return -1;
@@ -845,19 +845,19 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
if (sdp->gfs1) {
/* In gfs1, the license_di is always 3 blocks after the jindex_di */
- if ((sbd1->sb_license_di.no_addr != sbd1->sb_jindex_di.no_addr + 3) ||
- (sbd1->sb_license_di.no_formal_ino != sbd1->sb_jindex_di.no_addr + 3)) {
+ if ((sdp->sd_license_di.no_addr != sdp->sd_jindex_di.no_addr + 3) ||
+ (sdp->sd_license_di.no_formal_ino != sdp->sd_jindex_di.no_addr + 3)) {
if (!query( _("The gfs system statfs inode pointer is incorrect. "
"Okay to correct? (y/n) "))) {
log_err( _("fsck.gfs2 cannot continue without a valid "
"statfs file; aborting.\n"));
goto fail;
}
- sbd1->sb_license_di.no_addr = sbd1->sb_license_di.no_formal_ino
- = sbd1->sb_jindex_di.no_addr + 3;
+ sdp->sd_license_di.no_addr = sdp->sd_license_di.no_formal_ino
+ = sdp->sd_jindex_di.no_addr + 3;
}
- sdp->md.statfs = lgfs2_inode_read(sdp, sbd1->sb_license_di.no_addr);
+ sdp->md.statfs = lgfs2_inode_read(sdp, sdp->sd_license_di.no_addr);
if (sdp->md.statfs == NULL) {
log_crit(_("Error reading statfs inode: %s\n"), strerror(errno));
goto fail;
@@ -902,19 +902,19 @@ static int init_system_inodes(struct gfs2_sbd *sdp)
if (sdp->gfs1) {
/* In gfs1, the quota_di is always 2 blocks after the jindex_di */
- if ((sbd1->sb_quota_di.no_addr != sbd1->sb_jindex_di.no_addr + 2) ||
- (sbd1->sb_quota_di.no_formal_ino != sbd1->sb_jindex_di.no_addr + 2)) {
+ if ((sdp->sd_quota_di.no_addr != sdp->sd_jindex_di.no_addr + 2) ||
+ (sdp->sd_quota_di.no_formal_ino != sdp->sd_jindex_di.no_addr + 2)) {
if (!query( _("The gfs system quota inode pointer is incorrect. "
" Okay to correct? (y/n) "))) {
log_err( _("fsck.gfs2 cannot continue without a valid "
"quota file; aborting.\n"));
goto fail;
}
- sbd1->sb_quota_di.no_addr = sbd1->sb_quota_di.no_formal_ino
- = sbd1->sb_jindex_di.no_addr + 2;
+ sdp->sd_quota_di.no_addr = sdp->sd_quota_di.no_formal_ino
+ = sdp->sd_jindex_di.no_addr + 2;
}
- sdp->md.qinode = lgfs2_inode_read(sdp, sbd1->sb_quota_di.no_addr);
+ sdp->md.qinode = lgfs2_inode_read(sdp, sdp->sd_quota_di.no_addr);
if (sdp->md.qinode == NULL) {
log_crit(_("Error reading quota inode: %s\n"), strerror(errno));
goto fail;
@@ -991,11 +991,11 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct
gfs2_inode *ip)
int error;
if (ip->i_formal_ino == 2) {
- if (sdp->sd_sb.sb_master_dir.no_addr)
+ if (sdp->sd_meta_dir.no_addr)
return;
log_warn(_("Found system master directory at: 0x%"PRIx64".\n"),
ip->i_addr);
- sdp->sd_sb.sb_master_dir.no_addr = ip->i_addr;
+ sdp->sd_meta_dir.no_addr = ip->i_addr;
return;
}
if ((!sdp->gfs1 && ip->i_formal_ino == 3) ||
@@ -1015,7 +1015,7 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct
gfs2_inode *ip)
goto out_discard_ip;
}
fix_md.jiinode = child_ip;
- sdp->sd_sb.sb_master_dir.no_addr = ip->i_addr;
+ sdp->sd_meta_dir.no_addr = ip->i_addr;
log_warn(_("Found system master directory at: 0x%"PRIx64"\n"),
ip->i_addr);
return;
@@ -1033,8 +1033,7 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct
gfs2_inode *ip)
fix_md.pinode = ip;
error = dir_search(ip, "..", 2, NULL, &inum);
if (!error && inum.no_addr) {
- sdp->sd_sb.sb_master_dir.no_addr =
- inum.no_addr;
+ sdp->sd_meta_dir.no_addr = inum.no_addr;
log_warn(_("From per_node's '..' master directory backtracked to:
"
"0x%"PRIx64"\n"), inum.no_addr);
}
@@ -1080,7 +1079,7 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct
gfs2_inode *ip)
struct gfs2_inum inum;
int error;
- if (sdp->sd_sb.sb_root_dir.no_addr) /* if we know the root dinode */
+ if (sdp->sd_root_dir.no_addr) /* if we know the root dinode */
return; /* we don't need to find the root */
if (!is_dir(ip, sdp->gfs1)) /* if this isn't a directory */
return; /* it can't lead us to the root anyway */
@@ -1091,7 +1090,7 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct
gfs2_inode *ip)
if (ip->i_addr == ip->i_bh->b_blocknr) {
log_warn(_("Found the root directory at: 0x%"PRIx64".\n"),
ip->i_addr);
- sdp->sd_sb.sb_root_dir.no_addr = ip->i_addr;
+ sdp->sd_root_dir.no_addr = ip->i_addr;
return;
}
log_warn(_("The root dinode should be at block 0x%"PRIx64" but it
"
@@ -1105,7 +1104,7 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct
gfs2_inode *ip)
return;
}
root_bh = bread(sdp, ip->i_addr);
- memcpy(root_bh->b_data, ip->i_bh->b_data, sdp->bsize);
+ memcpy(root_bh->b_data, ip->i_bh->b_data, sdp->sd_bsize);
bmodified(root_bh);
brelse(root_bh);
log_warn(_("Root directory copied from the journal.\n"));
@@ -1116,7 +1115,7 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct
gfs2_inode *ip)
if (parent_ip && parent_ip->i_addr == ip->i_addr) {
log_warn(_("Found the root directory at: 0x%"PRIx64"\n"),
ip->i_addr);
- sdp->sd_sb.sb_root_dir.no_addr = ip->i_addr;
+ sdp->sd_root_dir.no_addr = ip->i_addr;
inode_put(&parent_ip);
inode_put(&ip);
return;
@@ -1150,7 +1149,7 @@ static int find_rgs_for_bsize(struct gfs2_sbd *sdp, uint64_t
startblock,
int found_rg;
struct gfs2_meta_header mh;
- sdp->bsize = GFS2_DEFAULT_BSIZE;
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
max_rg_size = 524288;
/* Max RG size is 2GB. Max block size is 4K. 2G / 4K blks = 524288,
So this is traversing 2GB in 4K block increments. */
@@ -1177,7 +1176,7 @@ static int find_rgs_for_bsize(struct gfs2_sbd *sdp, uint64_t
startblock,
rb_addr = (bh->b_blocknr *
(GFS2_DEFAULT_BSIZE / bsize2)) +
(bsize / bsize2) + 1;
- sdp->bsize = bsize2; /* temporarily */
+ sdp->sd_bsize = bsize2; /* temporarily */
rb_bh = bread(sdp, rb_addr);
gfs2_meta_header_in(&mh, rb_bh->b_data);
brelse(rb_bh);
@@ -1193,11 +1192,11 @@ static int find_rgs_for_bsize(struct gfs2_sbd *sdp, uint64_t
startblock,
}
brelse(bh);
if (!(*known_bsize)) {
- sdp->bsize = GFS2_DEFAULT_BSIZE;
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
continue;
}
- sdp->bsize = *known_bsize;
+ sdp->sd_bsize = *known_bsize;
log_warn(_("Block size determined to be: %d\n"), *known_bsize);
return 0;
}
@@ -1214,7 +1213,7 @@ static int peruse_metadata(struct gfs2_sbd *sdp, uint64_t
startblock)
struct gfs2_buffer_head *bh;
struct gfs2_inode *ip;
- max_rg_size = 2147483648ull / sdp->bsize;
+ max_rg_size = 2147483648ull / sdp->sd_bsize;
/* Max RG size is 2GB. 2G / bsize. */
for (blk = startblock; blk < startblock + max_rg_size; blk++) {
bh = bread(sdp, blk);
@@ -1245,7 +1244,7 @@ static int sb_repair(struct gfs2_sbd *sdp)
memset(&fix_md, 0, sizeof(fix_md));
/* Step 1 - First we need to determine the correct block size. */
- sdp->bsize = GFS2_DEFAULT_BSIZE;
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
log_warn(_("Gathering information to repair the gfs2 superblock. "
"This may take some time.\n"));
error = find_rgs_for_bsize(sdp, (GFS2_SB_ADDR * GFS2_BASIC_BLOCK) /
@@ -1257,7 +1256,7 @@ static int sb_repair(struct gfs2_sbd *sdp)
/* First, figure out the device size. We need that so we can
find a suitable start point to determine what's what. */
half = sdp->dinfo.size / 2; /* in bytes */
- half /= sdp->bsize;
+ half /= sdp->sd_bsize;
/* Start looking halfway through the device for gfs2
structures. If there aren't any at all, forget it. */
error = find_rgs_for_bsize(sdp, half, &known_bsize);
@@ -1274,11 +1273,11 @@ static int sb_repair(struct gfs2_sbd *sdp)
GFS2_DEFAULT_BSIZE);
if (error)
return error;
- if (!sdp->sd_sb.sb_master_dir.no_addr) {
+ if (!sdp->sd_meta_dir.no_addr) {
log_err(_("Unable to locate the system master directory.\n"));
return -1;
}
- if (!sdp->sd_sb.sb_root_dir.no_addr) {
+ if (!sdp->sd_root_dir.no_addr) {
struct gfs2_inum inum;
log_err(_("Unable to locate the root directory.\n"));
@@ -1287,11 +1286,11 @@ static int sb_repair(struct gfs2_sbd *sdp)
creates master immediately after root. */
log_err(_("Can't find any dinodes that might "
"be the root; using master - 1.\n"));
- possible_root = sdp->sd_sb.sb_master_dir.no_addr - 1;
+ possible_root = sdp->sd_meta_dir.no_addr - 1;
}
log_err(_("Found a possible root at: 0x%llx\n"),
(unsigned long long)possible_root);
- sdp->sd_sb.sb_root_dir.no_addr = possible_root;
+ sdp->sd_root_dir.no_addr = possible_root;
sdp->md.rooti = lgfs2_inode_read(sdp, possible_root);
if (!sdp->md.rooti || sdp->md.rooti->i_magic != GFS2_MAGIC) {
struct gfs2_buffer_head *bh = NULL;
@@ -1317,32 +1316,23 @@ static int sb_repair(struct gfs2_sbd *sdp)
}
/* Step 3 - Rebuild the lock protocol and file system table name */
if (query(_("Okay to fix the GFS2 superblock? (y/n)"))) {
- struct gfs2_sb sb;
log_info(_("Found system master directory at: 0x%"PRIx64"\n"),
- sdp->sd_sb.sb_master_dir.no_addr);
- sdp->master_dir = lgfs2_inode_read(sdp,
- sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->sd_meta_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
if (sdp->master_dir == NULL) {
log_crit(_("Error reading master inode: %s\n"), strerror(errno));
return -1;
}
- sdp->master_dir->i_addr = sdp->sd_sb.sb_master_dir.no_addr;
+ sdp->master_dir->i_addr = sdp->sd_meta_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,
- sdp->sd_sb.sb_root_dir.no_addr);
+ sdp->sd_root_dir.no_addr);
+ sdp->md.rooti = lgfs2_inode_read(sdp, sdp->sd_root_dir.no_addr);
if (sdp->md.rooti == NULL) {
log_crit(_("Error reading root inode: %s\n"), strerror(errno));
return -1;
}
- 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.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);
+ sdp->sd_fs_format = GFS2_FORMAT_FS;
+ lgfs2_sb_write(sdp, sdp->device_fd);
inode_put(&sdp->md.rooti);
inode_put(&sdp->master_dir);
sb_fixed = 1;
@@ -1366,24 +1356,10 @@ static int fill_super_block(struct gfs2_sbd *sdp)
sync();
- /********************************************************************
- ***************** First, initialize all lists **********************
- ********************************************************************/
log_info( _("Initializing lists...\n"));
sdp->rgtree.osi_node = NULL;
- /********************************************************************
- ************ next, read in on-disk SB and set constants **********
- ********************************************************************/
- sdp->sd_sb.sb_bsize = GFS2_DEFAULT_BSIZE;
- sdp->bsize = sdp->sd_sb.sb_bsize;
-
- if (sizeof(struct gfs2_sb) > sdp->sd_sb.sb_bsize){
- log_crit( _("GFS superblock is larger than the blocksize!\n"));
- log_debug("sizeof(struct gfs2_sb) > sdp->sd_sb.sb_bsize\n");
- return FSCK_ERROR;
- }
-
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
if (compute_constants(sdp)) {
log_crit("%s\n", _("Failed to compute file system constants"));
return FSCK_ERROR;
@@ -1397,10 +1373,8 @@ static int fill_super_block(struct gfs2_sbd *sdp)
if (ret < 0)
return FSCK_ERROR;
}
- if (sdp->gfs1)
- sbd1 = (struct gfs_sb *)&sdp->sd_sb;
- else if (sdp->sd_sb.sb_fs_format > FSCK_MAX_FORMAT) {
- log_crit(_("Unsupported gfs2 format found: %"PRIu32"\n"),
sdp->sd_sb.sb_fs_format);
+ if (!sdp->gfs1 && sdp->sd_fs_format > FSCK_MAX_FORMAT) {
+ log_crit(_("Unsupported gfs2 format found: %"PRIu32"\n"),
sdp->sd_fs_format);
log_crit(_("A newer fsck.gfs2 is required to check this file system.\n"));
return FSCK_USAGE;
}
@@ -1455,11 +1429,11 @@ static int reconstruct_single_journal(struct gfs2_sbd *sdp, int
jnum,
lh.lh_header.mh_format = GFS2_FORMAT_LH;
lh.lh_header.__pad0 = 0x101674; /* mh_generation */
lh.lh_flags = GFS2_LOG_HEAD_UNMOUNT;
- lh.lh_first = sdp->md.journal[jnum]->i_addr + (seg * sbd1->sb_seg_size);
+ lh.lh_first = sdp->md.journal[jnum]->i_addr + (seg * sdp->sd_seg_size);
lh.lh_sequence = sequence;
- bh = bget(sdp, lh.lh_first * sdp->bsize);
- memset(bh->b_data, 0, sdp->bsize);
+ bh = bget(sdp, lh.lh_first * sdp->sd_bsize);
+ memset(bh->b_data, 0, sdp->sd_bsize);
gfs_log_header_out(&lh, bh->b_data);
gfs_log_header_out(&lh, bh->b_data + GFS2_BASIC_BLOCK -
sizeof(struct gfs_log_header));
@@ -1471,21 +1445,20 @@ static int reconstruct_single_journal(struct gfs2_sbd *sdp, int
jnum,
return 0;
}
-static int reset_journal_seg_size(unsigned int jsize, unsigned int nsegs,
- unsigned int bsize)
+static int reset_journal_seg_size(struct gfs2_sbd *sdp, unsigned int jsize, unsigned int
nsegs)
{
- unsigned int seg_size = jsize / (nsegs * bsize);
+ unsigned int seg_size = jsize / (nsegs * sdp->sd_bsize);
if (!seg_size)
seg_size = 16; /* The default with 128MB journal and 4K bsize */
- if (seg_size != sbd1->sb_seg_size) {
- sbd1->sb_seg_size = seg_size;
+ if (seg_size != sdp->sd_seg_size) {
+ sdp->sd_seg_size = seg_size;
if (!query(_("Computed correct journal segment size to %u."
" Reset it? (y/n) "), seg_size)) {
log_crit(_("Error: Cannot proceed without a valid journal"
" segment size value.\n"));
return -1;
}
- log_err(_("Resetting journal segment size to %u\n"), sbd1->sb_seg_size);
+ log_err(_("Resetting journal segment size to %u\n"), sdp->sd_seg_size);
}
return 0;
}
@@ -1506,7 +1479,7 @@ static int correct_journal_seg_size(struct gfs2_sbd *sdp)
gfs_jindex_in(&ji_0, buf);
if (sdp->md.journals == 1) {
- if (sbd1->sb_seg_size == 0) {
+ if (sdp->sd_seg_size == 0) {
if (!query(_("The gfs2 journal segment size is 0 and a"
" correct value cannot be determined in a"
" single-journal filesystem.\n"
@@ -1532,9 +1505,9 @@ static int correct_journal_seg_size(struct gfs2_sbd *sdp)
}
gfs_jindex_in(&ji_1, buf);
- jsize = (ji_1.ji_addr - ji_0.ji_addr) * sbd1->sb_bsize;
+ jsize = (ji_1.ji_addr - ji_0.ji_addr) * sdp->sd_bsize;
out:
- return reset_journal_seg_size(jsize, ji_0.ji_nsegment, sbd1->sb_bsize);
+ return reset_journal_seg_size(sdp, jsize, ji_0.ji_nsegment);
}
/*
@@ -1580,7 +1553,7 @@ static int init_rindex(struct gfs2_sbd *sdp)
int err;
if (sdp->gfs1)
- sdp->md.riinode = lgfs2_inode_read(sdp, sbd1->sb_rindex_di.no_addr);
+ sdp->md.riinode = lgfs2_inode_read(sdp, sdp->sd_rindex_di.no_addr);
else
gfs2_lookupi(sdp->master_dir, "rindex", 6, &sdp->md.riinode);
@@ -1669,16 +1642,14 @@ int initialize(struct gfs2_sbd *sdp, int force_check, int preen,
if (sdp->gfs1)
sdp->master_dir = NULL;
else
- sdp->master_dir = lgfs2_inode_read(sdp,
- sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
if (!sdp->gfs1 &&
(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,
- sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
if (sdp->master_dir == NULL) {
log_crit(_("Error reading master directory: %s\n"), strerror(errno));
return FSCK_ERROR;
diff --git a/gfs2/fsck/metawalk.c b/gfs2/fsck/metawalk.c
index 2543e2e5..b699ca8d 100644
--- a/gfs2/fsck/metawalk.c
+++ b/gfs2/fsck/metawalk.c
@@ -322,13 +322,13 @@ static int dirent_repair(struct gfs2_inode *ip, struct
gfs2_buffer_head *bh,
/* If this is a sentinel, just fix the length and move on */
if (first && !de->de_inum.no_formal_ino) { /* Is it a sentinel? */
if (type == DIR_LINEAR)
- de->de_rec_len = ip->i_sbd->bsize -
+ de->de_rec_len = ip->i_sbd->sd_bsize -
sizeof(struct gfs2_dinode);
else
- de->de_rec_len = ip->i_sbd->bsize -
+ de->de_rec_len = ip->i_sbd->sd_bsize -
sizeof(struct gfs2_leaf);
} else {
- bh_end = bh->b_data + ip->i_sbd->bsize;
+ bh_end = bh->b_data + ip->i_sbd->sd_bsize;
/* first, figure out a probable name length */
p = (char *)dent + sizeof(struct gfs2_dirent);
while (*p && /* while there's a non-zero char and */
@@ -361,7 +361,7 @@ static void dirblk_truncate(struct gfs2_inode *ip, struct gfs2_dirent
*fixb,
char *bh_end;
struct gfs2_dirent de;
- bh_end = bh->b_data + ip->i_sbd->sd_sb.sb_bsize;
+ bh_end = bh->b_data + ip->i_sbd->sd_bsize;
/* truncate the block to save the most dentries. To do this we
have to patch the previous dent. */
gfs2_dirent_in(&de, (char *)fixb);
@@ -394,7 +394,7 @@ static int check_entries(struct gfs2_inode *ip, struct
gfs2_buffer_head *bh,
char *filename;
int first = 1;
- bh_end = bh->b_data + ip->i_sbd->bsize;
+ bh_end = bh->b_data + ip->i_sbd->sd_bsize;
if (type == DIR_LINEAR) {
dent = (struct gfs2_dirent *)(bh->b_data + sizeof(struct gfs2_dinode));
@@ -673,11 +673,11 @@ static void dir_leaf_reada(struct gfs2_inode *ip, uint64_t *tbl,
unsigned hsize)
for (i = 0; i < hsize; i++) {
leaf_no = be64_to_cpu(tbl[i]);
if (valid_block_ip(ip, leaf_no))
- t[n++] = leaf_no * sdp->bsize;
+ t[n++] = leaf_no * sdp->sd_bsize;
}
qsort(t, n, sizeof(uint64_t), u64cmp);
for (i = 0; i < n; i++)
- posix_fadvise(sdp->device_fd, t[i], sdp->bsize, POSIX_FADV_WILLNEED);
+ posix_fadvise(sdp->device_fd, t[i], sdp->sd_bsize, POSIX_FADV_WILLNEED);
}
/* Checks exhash directory entries */
@@ -890,14 +890,14 @@ static int check_eattr_entries(struct gfs2_inode *ip,
pass->private);
if (err)
error = err;
- tot_ealen += sdp->sd_sb.sb_bsize -
+ tot_ealen += sdp->sd_bsize -
sizeof(struct gfs2_meta_header);
ea_data_ptr++;
}
}
offset += be32_to_cpu(ea_hdr->ea_rec_len);
if (ea_hdr->ea_flags & GFS2_EAFLAG_LAST ||
- offset >= ip->i_sbd->sd_sb.sb_bsize || ea_hdr->ea_rec_len == 0){
+ offset >= ip->i_sbd->sd_bsize || ea_hdr->ea_rec_len == 0){
break;
}
ea_hdr_prev = ea_hdr;
@@ -970,7 +970,7 @@ static int check_indirect_eattr(struct gfs2_inode *ip, uint64_t
indirect,
int leaf_pointers = 0, leaf_pointer_errors = 0;
ea_leaf_ptr = (uint64_t *)(indirect_buf->b_data + offset);
- end = ea_leaf_ptr + ((sdp->sd_sb.sb_bsize - offset) / 8);
+ end = ea_leaf_ptr + ((sdp->sd_bsize - offset) / 8);
while (*ea_leaf_ptr && (ea_leaf_ptr < end)){
block = be64_to_cpu(*ea_leaf_ptr);
@@ -1123,8 +1123,8 @@ static void file_ra(struct gfs2_inode *ip, struct gfs2_buffer_head
*bh,
extlen = block - sblock;
if (extlen > 1 && extlen <= maxptrs) {
posix_fadvise(sdp->device_fd,
- sblock * sdp->bsize,
- (extlen + 1) * sdp->bsize,
+ sblock * sdp->sd_bsize,
+ (extlen + 1) * sdp->sd_bsize,
POSIX_FADV_WILLNEED);
return;
}
@@ -1132,7 +1132,7 @@ static void file_ra(struct gfs2_inode *ip, struct gfs2_buffer_head
*bh,
extlen = 0;
}
for (p = (uint64_t *)(bh->b_data + head_size);
- p < (uint64_t *)(bh->b_data + sdp->bsize); p++) {
+ p < (uint64_t *)(bh->b_data + sdp->sd_bsize); p++) {
if (*p) {
if (!sblock) {
sblock = be64_to_cpu(*p);
@@ -1148,16 +1148,16 @@ static void file_ra(struct gfs2_inode *ip, struct gfs2_buffer_head
*bh,
if (extlen && sblock) {
if (extlen > 1)
extlen--;
- posix_fadvise(sdp->device_fd, sblock * sdp->bsize,
- extlen * sdp->bsize,
+ posix_fadvise(sdp->device_fd, sblock * sdp->sd_bsize,
+ extlen * sdp->sd_bsize,
POSIX_FADV_WILLNEED);
extlen = 0;
p--;
}
}
if (extlen)
- posix_fadvise(sdp->device_fd, sblock * sdp->bsize,
- extlen * sdp->bsize, POSIX_FADV_WILLNEED);
+ posix_fadvise(sdp->device_fd, sblock * sdp->sd_bsize,
+ extlen * sdp->sd_bsize, POSIX_FADV_WILLNEED);
}
static int do_check_metalist(struct iptr iptr, int height, struct gfs2_buffer_head
**bhp,
@@ -1252,7 +1252,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip,
osi_list_t *mlp,
iblk_type = GFS2_METATYPE_IN;
if (ip->i_sbd->gfs1) {
head_size = sizeof(struct gfs_indirect);
- maxptrs = (ip->i_sbd->bsize - head_size) /
+ maxptrs = (ip->i_sbd->sd_bsize - head_size) /
sizeof(uint64_t);
} else {
head_size = sizeof(struct gfs2_meta_header);
@@ -1280,7 +1280,7 @@ static int build_and_check_metalist(struct gfs2_inode *ip,
osi_list_t *mlp,
file_ra(ip, iptr.ipt_bh, head_size, maxptrs, h);
/* Now check the metadata itself */
- for (; iptr.ipt_off < ip->i_sbd->bsize; iptr.ipt_off += sizeof(uint64_t)) {
+ for (; iptr.ipt_off < ip->i_sbd->sd_bsize; iptr.ipt_off += sizeof(uint64_t))
{
struct gfs2_buffer_head *nbh = NULL;
if (skip_this_pass || fsck_abort)
@@ -1398,7 +1398,7 @@ static int metawalk_check_data(struct gfs2_inode *ip, struct
metawalk_fxns *pass
int error = 0, rc = 0;
uint64_t block;
__be64 *ptr_start = (uint64_t *)(bh->b_data + hdr_size(bh, height));
- __be64 *ptr_end = (uint64_t *)(bh->b_data + ip->i_sbd->bsize);
+ __be64 *ptr_end = (uint64_t *)(bh->b_data + ip->i_sbd->sd_bsize);
__be64 *ptr;
uint64_t metablock = bh->b_blocknr;
@@ -1464,7 +1464,7 @@ static int undo_check_data(struct gfs2_inode *ip, struct
metawalk_fxns *pass,
struct error_block *error_blk, int error)
{
__be64 *ptr_start = (uint64_t *)(bh->b_data + hdr_size(bh, height));
- __be64 *ptr_end = (uint64_t *)(bh->b_data + ip->i_sbd->bsize);
+ __be64 *ptr_end = (uint64_t *)(bh->b_data + ip->i_sbd->sd_bsize);
__be64 *ptr;
uint64_t metablock = bh->b_blocknr;
int rc = 0;
diff --git a/gfs2/fsck/metawalk.h b/gfs2/fsck/metawalk.h
index f63ed5cf..f6c6bc31 100644
--- a/gfs2/fsck/metawalk.h
+++ b/gfs2/fsck/metawalk.h
@@ -50,7 +50,7 @@ struct iptr {
#define iptr_ptr(i) ((uint64_t *)(i.ipt_bh->b_data + i.ipt_off))
#define iptr_block(i) be64_to_cpu(*iptr_ptr(i))
-#define iptr_endptr(i) ((uint64_t *)(iptr.ipt_bh->b_data +
i.ipt_ip->i_sbd->bsize))
+#define iptr_endptr(i) ((uint64_t *)(iptr.ipt_bh->b_data +
i.ipt_ip->i_sbd->sd_bsize))
#define iptr_buf(i) (i.ipt_bh->b_data)
/* metawalk_fxns: function pointers to check various parts of the fs
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index f2ba4235..047a96b0 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -898,7 +898,7 @@ static int ask_remove_eattr_entry(struct gfs2_sbd *sdp,
if (fix_curr)
curr->ea_flags |= GFS2_EAFLAG_LAST;
if (fix_curr_len) {
- uint32_t max_size = sdp->sd_sb.sb_bsize;
+ uint32_t max_size = sdp->sd_bsize;
uint32_t offset = (uint32_t)(((unsigned long)curr) -
((unsigned long)leaf_bh->b_data));
curr->ea_rec_len = cpu_to_be32(max_size - offset);
@@ -938,7 +938,7 @@ static int check_eattr_entries(struct gfs2_inode *ip,
char ea_name[256];
uint32_t offset = (uint32_t)(((unsigned long)ea_hdr) -
((unsigned long)leaf_bh->b_data));
- uint32_t max_size = sdp->sd_sb.sb_bsize;
+ uint32_t max_size = sdp->sd_bsize;
uint32_t avail_size;
int max_ptrs;
@@ -968,11 +968,11 @@ static int check_eattr_entries(struct gfs2_inode *ip,
strncpy(ea_name, (char *)ea_hdr + sizeof(struct gfs2_ea_header),
ea_hdr->ea_name_len);
- if (ea_hdr->ea_type > eatype_max(sdp->sd_sb.sb_fs_format) &&
+ if (ea_hdr->ea_type > eatype_max(sdp->sd_fs_format) &&
((ea_hdr_prev) || (!ea_hdr_prev && ea_hdr->ea_type))){
/* Skip invalid entry */
log_err(_("EA (%s) type is invalid (%d > %d).\n"),
- ea_name, ea_hdr->ea_type, eatype_max(sdp->sd_sb.sb_fs_format));
+ ea_name, ea_hdr->ea_type, eatype_max(sdp->sd_fs_format));
return ask_remove_eattr_entry(sdp, leaf_bh, ea_hdr,
ea_hdr_prev, 0, 0);
}
@@ -980,7 +980,7 @@ static int check_eattr_entries(struct gfs2_inode *ip,
if (!ea_hdr->ea_num_ptrs)
return 0;
- avail_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
+ avail_size = sdp->sd_bsize - sizeof(struct gfs2_meta_header);
max_ptrs = (be32_to_cpu(ea_hdr->ea_data_len)+avail_size-1)/avail_size;
if (max_ptrs > ea_hdr->ea_num_ptrs) {
@@ -1812,7 +1812,7 @@ static int pass1_process_bitmap(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd, uin
int q;
/* Readahead numbers arrived at by experiment */
unsigned rawin = 50;
- unsigned ralen = 100 * sdp->bsize;
+ unsigned ralen = 100 * sdp->sd_bsize;
unsigned r = 0;
for (i = 0; i < n; i++) {
@@ -1822,7 +1822,7 @@ static int pass1_process_bitmap(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd, uin
block = ibuf[i];
if (r++ == rawin) {
- posix_fadvise(sdp->device_fd, block * sdp->bsize, ralen, POSIX_FADV_WILLNEED);
+ posix_fadvise(sdp->device_fd, block * sdp->sd_bsize, ralen,
POSIX_FADV_WILLNEED);
r = 0;
}
@@ -1938,7 +1938,7 @@ static int pass1_process_bitmap(struct gfs2_sbd *sdp, struct
rgrp_tree *rgd, uin
static int pass1_process_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
{
unsigned k, n, i;
- uint64_t *ibuf = malloc(sdp->bsize * GFS2_NBBY * sizeof(uint64_t));
+ uint64_t *ibuf = malloc(sdp->sd_bsize * GFS2_NBBY * sizeof(uint64_t));
int ret = 0;
if (ibuf == NULL)
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index d5fe61b3..d8d08056 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -1017,7 +1017,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
dip->i_blocks++;
bmodified(dip->i_bh);
nbh = bget(dip->i_sbd, *bn);
- memset(nbh->b_data, 0, dip->i_sbd->bsize);
+ memset(nbh->b_data, 0, dip->i_sbd->sd_bsize);
leaf = (struct gfs2_leaf *)nbh->b_data;
leaf->lf_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
leaf->lf_header.mh_type = cpu_to_be32(GFS2_METATYPE_LF);
@@ -1026,7 +1026,7 @@ static int write_new_leaf(struct gfs2_inode *dip, int start_lindex,
/* initialize the first dirent on the new leaf block */
dent = (struct gfs2_dirent *)(nbh->b_data + sizeof(struct gfs2_leaf));
- dent->de_rec_len = cpu_to_be16(dip->i_sbd->bsize -
+ dent->de_rec_len = cpu_to_be16(dip->i_sbd->sd_bsize -
sizeof(struct gfs2_leaf));
bmodified(nbh);
brelse(nbh);
@@ -1119,7 +1119,7 @@ static int lost_leaf(struct gfs2_inode *ip, uint64_t *tbl, uint64_t
leafno,
int ref_count, int lindex, struct gfs2_buffer_head *bh)
{
char *filename;
- char *bh_end = bh->b_data + ip->i_sbd->bsize;
+ char *bh_end = bh->b_data + ip->i_sbd->sd_bsize;
struct gfs2_dirent de, *dent;
int error;
int isdir = 0;
@@ -1382,7 +1382,7 @@ static int fix_hashtable(struct gfs2_inode *ip, uint64_t *tbl,
unsigned hsize,
gfs2_dirent_in(&dentry, (char *)de);
/* If this is an empty leaf, we can just delete it and pad. */
- if ((dentry.de_rec_len == cpu_to_be16(ip->i_sbd->bsize -
+ if ((dentry.de_rec_len == cpu_to_be16(ip->i_sbd->sd_bsize -
sizeof(struct gfs2_leaf))) &&
(dentry.de_inum.no_formal_ino == 0)) {
brelse(lbh);
diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c
index 029f0711..fbdc4f34 100644
--- a/gfs2/fsck/rgrepair.c
+++ b/gfs2/fsck/rgrepair.c
@@ -60,7 +60,7 @@ static void find_journaled_rgs(struct gfs2_sbd *sdp)
ip = sdp->md.journal[j];
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;
+ jblocks = ip->i_size / sdp->sd_bsize;
false_count = 0;
for (b = 0; b < jblocks; b++) {
block_map(ip, b, &new, &dblock, NULL, 0);
@@ -276,7 +276,7 @@ static uint64_t count_usedspace(struct gfs2_sbd *sdp, int first,
off = sizeof(struct gfs2_rgrp);
} else
off = sizeof(struct gfs2_meta_header);
- bytes_to_check = sdp->bsize - off;
+ bytes_to_check = sdp->sd_bsize - off;
for (x = 0; x < bytes_to_check; x++) {
unsigned char *byte;
@@ -336,7 +336,7 @@ static uint64_t find_next_rgrp_dist(struct gfs2_sbd *sdp, uint64_t
blk,
rgrp_dist = next_rgd->rt_addr - rgd->rt_addr;
return rgrp_dist;
}
- mega_in_blocks = (1024 * 1024) / sdp->bsize;
+ mega_in_blocks = (1024 * 1024) / sdp->sd_bsize;
twogigs = (uint64_t)mega_in_blocks * 2048;
/* Unfortunately, if we fall through to here we can't trust the
rindex. So we have to analyze the current rgrp to figure out
@@ -453,7 +453,7 @@ static uint64_t hunt_and_peck(struct gfs2_sbd *sdp, uint64_t blk,
/* Now we account for block rounding done by mkfs.gfs2. A rgrp can
be at most 2GB in size, so that's where we call it. We do somewhat
obscure math here to avoid integer overflows. */
- mega_in_blocks = (1024 * 1024) / sdp->bsize;
+ mega_in_blocks = (1024 * 1024) / sdp->sd_bsize;
twogigs = 2048 * mega_in_blocks;
if (block + twogigs <= sdp->fssize) {
last_block = twogigs;
@@ -599,7 +599,7 @@ static int rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs, int
gfs_grow)
if (prev_rgd) {
uint32_t rgblocks;
- prev_rgd->rt_length = rgblocks2bitblocks(sdp->bsize, block_bump,
&rgblocks);
+ prev_rgd->rt_length = rgblocks2bitblocks(sdp->sd_bsize, block_bump,
&rgblocks);
prev_rgd->rt_data = rgblocks;
prev_rgd->rt_data0 = prev_rgd->rt_addr +
prev_rgd->rt_length;
@@ -661,7 +661,7 @@ static int rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs, int
gfs_grow)
if (prev_rgd && !prev_rgd->rt_data) {
uint32_t rgblocks;
- prev_rgd->rt_length = rgblocks2bitblocks(sdp->bsize, block_bump, &rgblocks);
+ prev_rgd->rt_length = rgblocks2bitblocks(sdp->sd_bsize, block_bump,
&rgblocks);
prev_rgd->rt_data0 = prev_rgd->rt_addr + prev_rgd->rt_length;
prev_rgd->rt_data = rgblocks;
prev_rgd->rt_data -= prev_rgd->rt_data % GFS2_NBBY;
@@ -707,12 +707,12 @@ static uint64_t how_many_rgrps(struct gfs2_sbd *sdp, struct device
*dev, int rgs
int bitmap_overflow = 0;
while (1) {
- nrgrp = DIV_RU(dev->length, (sdp->rgsize << 20) / sdp->bsize);
+ nrgrp = DIV_RU(dev->length, (sdp->rgsize << 20) / sdp->sd_bsize);
/* check to see if the rg length overflows max # bitblks */
- bitblocksn = rgblocks2bitblocks(sdp->bsize, dev->length / nrgrp,
&rgblocksn);
+ bitblocksn = rgblocks2bitblocks(sdp->sd_bsize, dev->length / nrgrp,
&rgblocksn);
/* calculate size of the first rgrp */
- bitblocks1 = rgblocks2bitblocks(sdp->bsize, dev->length - (nrgrp - 1) *
(dev->length / nrgrp),
+ bitblocks1 = rgblocks2bitblocks(sdp->sd_bsize, dev->length - (nrgrp - 1) *
(dev->length / nrgrp),
&rgblocks1);
if (bitblocks1 > 2149 || bitblocksn > 2149) {
bitmap_overflow = 1;
@@ -720,7 +720,7 @@ static uint64_t how_many_rgrps(struct gfs2_sbd *sdp, struct device
*dev, int rgs
fprintf(stderr, "error: It is not possible "
"to use the entire device with "
"block size %u bytes.\n",
- sdp->bsize);
+ sdp->sd_bsize);
exit(-1);
}
sdp->rgsize -= GFS2_DEFAULT_RGSIZE; /* smaller rgs */
@@ -820,7 +820,7 @@ static int calc_rgrps(struct gfs2_sbd *sdp)
next = osi_next(n);
rl = (struct rgrp_tree *)n;
- bitblocks = rgblocks2bitblocks(sdp->bsize, rl->length, &rgblocks);
+ bitblocks = rgblocks2bitblocks(sdp->sd_bsize, rl->length, &rgblocks);
rl->rt_addr = rl->start;
rl->rt_length = bitblocks;
@@ -829,7 +829,7 @@ static int calc_rgrps(struct gfs2_sbd *sdp)
rl->rt_bitbytes = rgblocks / GFS2_NBBY;
rl->rt_free = rgblocks;
- if (gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, rl))
+ if (gfs2_compute_bitstructs(sdp->sd_bsize, rl))
return -1;
sdp->blks_total += rgblocks;
@@ -909,13 +909,13 @@ static int rewrite_rg_block(struct gfs2_sbd *sdp, struct rgrp_tree
*rg,
log_err(_("Attempting to repair the resource group.\n"));
- buf = calloc(1, sdp->bsize);
+ buf = calloc(1, sdp->sd_bsize);
if (buf == NULL) {
log_err(_("Failed to allocate resource group block: %s"), strerror(errno));
return 1;
}
- ret = pread(sdp->device_fd, buf, sdp->bsize, errblock * sdp->bsize);
- if (ret != sdp->bsize) {
+ ret = pread(sdp->device_fd, buf, sdp->sd_bsize, errblock * sdp->sd_bsize);
+ if (ret != sdp->sd_bsize) {
log_err(_("Failed to read resource group block %"PRIu64": %s\n"),
errblock, strerror(errno));
free(buf);
@@ -935,8 +935,8 @@ static int rewrite_rg_block(struct gfs2_sbd *sdp, struct rgrp_tree
*rg,
else
lgfs2_rgrp_out(rg, buf);
}
- ret = pwrite(sdp->device_fd, buf, sdp->bsize, errblock * sdp->bsize);
- if (ret != sdp->bsize) {
+ ret = pwrite(sdp->device_fd, buf, sdp->sd_bsize, errblock * sdp->sd_bsize);
+ if (ret != sdp->sd_bsize) {
log_err(_("Failed to write resource group block %"PRIu64": %s\n"),
errblock, strerror(errno));
free(buf);
@@ -977,7 +977,7 @@ static int expect_rindex_sanity(struct gfs2_sbd *sdp, int *num_rgs)
exp->rt_dinodes = rgd->rt_dinodes;
exp->rt_skip = rgd->rt_skip;
exp->bits = NULL;
- gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, exp);
+ gfs2_compute_bitstructs(sdp->sd_bsize, exp);
}
sdp->rgrps = *num_rgs;
return 0;
@@ -1213,7 +1213,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *ok)
}
else
log_err( _("rindex not fixed.\n"));
- gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, actual);
+ gfs2_compute_bitstructs(sdp->sd_bsize, actual);
rindex_modified = 0;
}
e = enext;
diff --git a/gfs2/fsck/util.c b/gfs2/fsck/util.c
index dfc4512c..962ec1e0 100644
--- a/gfs2/fsck/util.c
+++ b/gfs2/fsck/util.c
@@ -44,7 +44,7 @@ void big_file_comfort(struct gfs2_inode *ip, uint64_t blks_checked)
fsize = ip->i_size;
for (i = 0; i < 6 && fsize > 1024; i++)
fsize /= 1024;
- chksize = blks_checked * ip->i_sbd->bsize;
+ chksize = blks_checked * ip->i_sbd->sd_bsize;
for (cs = 0; cs < 6 && chksize > 1024; cs++)
chksize /= 1024;
seconds = tv.tv_sec;
@@ -563,7 +563,7 @@ uint64_t find_free_blk(struct gfs2_sbd *sdp)
char *buf = rl->bits[block].bi_data;
x = (block) ? sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_rgrp);
- for (; x < sdp->bsize; x++)
+ for (; x < sdp->sd_bsize; x++)
for (y = 0; y < GFS2_NBBY; y++) {
state = (buf[x] >> (GFS2_BIT_SIZE * y)) & 0x03;
if (state == GFS2_BLKST_FREE)
diff --git a/gfs2/glocktop/glocktop.c b/gfs2/glocktop/glocktop.c
index c0fc0ceb..e7282517 100644
--- a/gfs2/glocktop/glocktop.c
+++ b/gfs2/glocktop/glocktop.c
@@ -156,7 +156,7 @@ struct mount_point {
char *device;
char *dir;
int fd;
- struct gfs2_sb sb;
+ struct gfs2_sbd sb;
};
struct mount_point *mounts;
char dlmwlines[MAX_LINES][96]; /* waiters lines */
@@ -223,7 +223,7 @@ static void UpdateSize(int sig)
signal(SIGWINCH, UpdateSize);
}
-static int read_superblock(int fd, struct gfs2_sb *sb)
+static int read_superblock(int fd, struct gfs2_sbd *sdp)
{
ssize_t r;
char *buf;
@@ -240,10 +240,10 @@ static int read_superblock(int fd, struct gfs2_sb *sb)
free(buf);
return -1;
}
- gfs2_sb_in(sb, buf);
+ lgfs2_sb_in(sdp, buf);
free(buf);
- bsize = sb->sb_bsize;
+ bsize = sdp->sd_bsize;
if (!bsize)
bsize = 4096;
return 0;
@@ -618,7 +618,7 @@ static const char *show_inode(const char *id, int fd, unsigned long
long block)
{
struct gfs2_inode *ip;
const char *inode_type = NULL;
- struct gfs2_sbd sbd = { .device_fd = fd, .bsize = bsize };
+ struct gfs2_sbd sbd = { .device_fd = fd, .sd_bsize = bsize };
ip = lgfs2_inode_read(&sbd, block);
if (S_ISDIR(ip->i_mode)) {
@@ -674,7 +674,7 @@ static const char *show_details(const char *id, const char *fsname,
int btype,
for (mp = mounts; mp != NULL; mp = mp->next) {
char *p;
- p = strchr(mp->sb.sb_locktable, ':');
+ p = strchr(mp->sb.sd_locktable, ':');
if (!p)
continue;
p++;
@@ -686,7 +686,7 @@ static const char *show_details(const char *id, const char *fsname,
int btype,
memset(dlm_dirtbl_size, 0, sizeof(dlm_dirtbl_size));
memset(dlm_rsbtbl_size, 0, sizeof(dlm_rsbtbl_size));
memset(dlm_lkbtbl_size, 0, sizeof(dlm_lkbtbl_size));
- if (!strcmp(mp->sb.sb_lockproto, "lock_dlm")) {
+ if (!strcmp(mp->sb.sd_lockproto, "lock_dlm")) {
char *sp;
char *p;
diff --git a/gfs2/libgfs2/buf.c b/gfs2/libgfs2/buf.c
index 22144d68..e317625f 100644
--- a/gfs2/libgfs2/buf.c
+++ b/gfs2/libgfs2/buf.c
@@ -26,14 +26,14 @@ struct gfs2_buffer_head *bget(struct gfs2_sbd *sdp, uint64_t num)
{
struct gfs2_buffer_head *bh;
- bh = calloc(1, sizeof(struct gfs2_buffer_head) + sdp->bsize);
+ bh = calloc(1, sizeof(struct gfs2_buffer_head) + sdp->sd_bsize);
if (bh == NULL)
return NULL;
bh->b_blocknr = num;
bh->sdp = sdp;
bh->iov.iov_base = (char *)bh + sizeof(struct gfs2_buffer_head);
- bh->iov.iov_len = sdp->bsize;
+ bh->iov.iov_len = sdp->sd_bsize;
return bh;
}
@@ -59,7 +59,7 @@ int __breadm(struct gfs2_sbd *sdp, struct gfs2_buffer_head **bhs, size_t
n,
size += bhs[i + j]->iov.iov_len;
}
- ret = preadv(sdp->device_fd, iovbase, j, (block + i) * sdp->bsize);
+ ret = preadv(sdp->device_fd, iovbase, j, (block + i) * sdp->sd_bsize);
if (ret != size) {
fprintf(stderr, "bad read: %s from %s:%d: block %llu (0x%llx) "
"count: %d size: %zd ret: %zd\n", strerror(errno),
@@ -82,8 +82,8 @@ struct gfs2_buffer_head *__bread(struct gfs2_sbd *sdp, uint64_t num, int
line,
if (bh == NULL)
return NULL;
- ret = pread(sdp->device_fd, bh->b_data, sdp->bsize, num * sdp->bsize);
- if (ret != sdp->bsize) {
+ ret = pread(sdp->device_fd, bh->b_data, sdp->sd_bsize, num *
sdp->sd_bsize);
+ if (ret != sdp->sd_bsize) {
fprintf(stderr, "%s:%d: Error reading block %"PRIu64": %s\n",
caller, line, num, strerror(errno));
free(bh);
@@ -96,7 +96,7 @@ int bwrite(struct gfs2_buffer_head *bh)
{
struct gfs2_sbd *sdp = bh->sdp;
- if (pwritev(sdp->device_fd, &bh->iov, 1, bh->b_blocknr * sdp->bsize) !=
bh->iov.iov_len)
+ if (pwritev(sdp->device_fd, &bh->iov, 1, bh->b_blocknr * sdp->sd_bsize)
!= bh->iov.iov_len)
return -1;
bh->b_modified = 0;
return 0;
diff --git a/gfs2/libgfs2/check_rgrp.c b/gfs2/libgfs2/check_rgrp.c
index dd31a341..5178c7a7 100644
--- a/gfs2/libgfs2/check_rgrp.c
+++ b/gfs2/libgfs2/check_rgrp.c
@@ -34,7 +34,7 @@ static void mockup_rgrps(void)
ck_assert(unlink(tmpnam) == 0);
ck_assert(ftruncate(sdp->device_fd, MOCK_DEV_SIZE) == 0);
- sdp->bsize = sdp->sd_sb.sb_bsize = 4096;
+ sdp->sd_bsize = 4096;
compute_constants(sdp);
rgs = lgfs2_rgrps_init(sdp, 0, 0);
@@ -115,7 +115,7 @@ START_TEST(test_rbm_find_lastblock)
/* Flag all blocks as allocated... */
for (i = 0; i < rg->rt_length; i++)
- memset(rg->bits[i].bi_data, 0xff, rgs->sdp->bsize);
+ memset(rg->bits[i].bi_data, 0xff, rgs->sdp->sd_bsize);
/* ...except the final one */
err = gfs2_set_bitmap(rg, rg->rt_data0 + rg->rt_data - 1, GFS2_BLKST_FREE);
diff --git a/gfs2/libgfs2/device_geometry.c b/gfs2/libgfs2/device_geometry.c
index 72f9c7e4..4a0aeab2 100644
--- a/gfs2/libgfs2/device_geometry.c
+++ b/gfs2/libgfs2/device_geometry.c
@@ -97,7 +97,7 @@ void fix_device_geometry(struct gfs2_sbd *sdp)
{
struct device *device = &sdp->device;
- device->length = sdp->dinfo.size / sdp->bsize;
+ device->length = sdp->dinfo.size / sdp->sd_bsize;
if (cfg_debug) {
printf("\nDevice Geometry: (in FS blocks)\n");
diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index c0569257..f7205393 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
@@ -219,7 +219,7 @@ int lgfs2_meta_alloc(struct gfs2_inode *ip, uint64_t *blkno)
static __inline__ void buffer_clear_tail(struct gfs2_sbd *sdp,
struct gfs2_buffer_head *bh, int head)
{
- memset(bh->b_data + head, 0, sdp->bsize - head);
+ memset(bh->b_data + head, 0, sdp->sd_bsize - head);
bmodified(bh);
}
@@ -229,8 +229,8 @@ buffer_copy_tail(struct gfs2_sbd *sdp,
struct gfs2_buffer_head *from_bh, int from_head)
{
memcpy(to_bh->b_data + to_head, from_bh->b_data + from_head,
- sdp->bsize - from_head);
- memset(to_bh->b_data + sdp->bsize + to_head - from_head, 0,
+ sdp->sd_bsize - from_head);
+ memset(to_bh->b_data + sdp->sd_bsize + to_head - from_head, 0,
from_head - to_head);
bmodified(to_bh);
}
@@ -316,7 +316,7 @@ int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct
gfs2_inode *ip, u
unsigned extlen;
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);
+ uint32_t blocks = lgfs2_space_for_data(sdp, sdp->sd_bsize, di_size);
if (ip->i_addr != 0) {
if (lgfs2_rbm_from_block(&rbm, ip->i_addr) != 0)
@@ -344,7 +344,7 @@ int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct
gfs2_inode *ip, u
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_goal_meta = ip->i_goal_data - ((di_size + sdp->sd_bsize - 1) /
sdp->sd_bsize);
ip->i_height = calc_tree_height(ip, di_size);
ip->i_flags = flags;
@@ -491,7 +491,7 @@ void block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
return;
}
- bsize = (S_ISDIR(ip->i_mode)) ? sdp->sd_jbsize : sdp->bsize;
+ bsize = (S_ISDIR(ip->i_mode)) ? sdp->sd_jbsize : sdp->sd_bsize;
height = calc_tree_height(ip, (lblock + 1) * bsize);
if (ip->i_height < height) {
@@ -600,8 +600,8 @@ int gfs2_readi(struct gfs2_inode *ip, void *buf,
o = lblock % sdp->sd_jbsize;
lblock /= sdp->sd_jbsize;
} else {
- lblock = offset >> sdp->sd_sb.sb_bsize_shift;
- o = offset & (sdp->bsize - 1);
+ lblock = offset >> sdp->sd_bsize_shift;
+ o = offset & (sdp->sd_bsize - 1);
}
if (inode_is_stuffed(ip))
@@ -611,8 +611,8 @@ int gfs2_readi(struct gfs2_inode *ip, void *buf,
while (copied < size) {
amount = size - copied;
- if (amount > sdp->bsize - o)
- amount = sdp->bsize - o;
+ if (amount > sdp->sd_bsize - o)
+ amount = sdp->sd_bsize - o;
if (!extlen) {
if (sdp->gfs1)
@@ -677,7 +677,7 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf,
return 0;
if (inode_is_stuffed(ip) &&
- ((start + size) > (sdp->bsize - sizeof(struct gfs2_dinode))))
+ ((start + size) > (sdp->sd_bsize - sizeof(struct gfs2_dinode))))
unstuff_dinode(ip);
if (isdir) {
@@ -685,8 +685,8 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf,
o = lblock % sdp->sd_jbsize;
lblock /= sdp->sd_jbsize;
} else {
- lblock = offset >> sdp->sd_sb.sb_bsize_shift;
- o = offset & (sdp->bsize - 1);
+ lblock = offset >> sdp->sd_bsize_shift;
+ o = offset & (sdp->sd_bsize - 1);
}
if (inode_is_stuffed(ip))
@@ -696,8 +696,8 @@ int __gfs2_writei(struct gfs2_inode *ip, void *buf,
while (copied < size) {
amount = size - copied;
- if (amount > sdp->bsize - o)
- amount = sdp->bsize - o;
+ if (amount > sdp->sd_bsize - o)
+ amount = sdp->sd_bsize - o;
if (!extlen) {
new = 1;
@@ -760,7 +760,7 @@ int gfs2_dirent_next(struct gfs2_inode *dip, struct gfs2_buffer_head
*bh,
char *bh_end;
uint16_t cur_rec_len;
- bh_end = bh->b_data + dip->i_sbd->bsize;
+ bh_end = bh->b_data + dip->i_sbd->sd_bsize;
cur_rec_len = be16_to_cpu((*dent)->de_rec_len);
if (cur_rec_len == 0 || (char *)(*dent) + cur_rec_len >= bh_end)
@@ -797,7 +797,7 @@ static int dirent_alloc(struct gfs2_inode *dip, struct
gfs2_buffer_head *bh,
}
if (!entries) {
- dent->de_rec_len = cpu_to_be16(dip->i_sbd->bsize - offset);
+ dent->de_rec_len = cpu_to_be16(dip->i_sbd->sd_bsize - offset);
dent->de_name_len = cpu_to_be16(name_len);
bmodified(bh);
*dent_out = dent;
@@ -1042,12 +1042,12 @@ static void dir_double_exhash(struct gfs2_inode *dip)
if (sdp->gfs1)
count = gfs1_writei(dip, (char *)buf +
sdp->sd_hash_bsize,
- block * sdp->bsize, sdp->bsize);
+ block * sdp->sd_bsize, sdp->sd_bsize);
else
count = gfs2_writei(dip, (char *)buf +
sdp->sd_hash_bsize,
- block * sdp->bsize, sdp->bsize);
- if (count != sdp->bsize) {
+ block * sdp->sd_bsize, sdp->sd_bsize);
+ if (count != sdp->sd_bsize) {
fprintf(stderr, "dir_double_exhash (2)\n");
exit(1);
}
@@ -1278,7 +1278,7 @@ static void dir_make_exhash(struct gfs2_inode *dip)
for (x = sdp->sd_hash_ptrs; x--; lp++)
*lp = cpu_to_be64(bn);
- dip->i_size = sdp->bsize / 2;
+ dip->i_size = sdp->sd_bsize / 2;
dip->i_blocks++;
dip->i_flags |= GFS2_DIF_EXHASH;
dip->i_payload_format = 0;
@@ -1379,7 +1379,7 @@ static int __init_dinode(struct gfs2_sbd *sdp, struct
gfs2_buffer_head **bhp, st
p += len;
hash = gfs2_disk_hash("..", 2);
- len = sdp->bsize - (p - bh->b_data);
+ len = sdp->sd_bsize - (p - bh->b_data);
de.de_inum.no_formal_ino = cpu_to_be64(parent->no_formal_ino);
de.de_inum.no_addr = cpu_to_be64(parent->no_addr);
de.de_hash = cpu_to_be32(hash);
@@ -1392,7 +1392,7 @@ static int __init_dinode(struct gfs2_sbd *sdp, struct
gfs2_buffer_head **bhp, st
*p = '.';
di->di_nlink = cpu_to_be32(2);
- di->di_size = cpu_to_be64(sdp->bsize - sizeof(struct gfs2_dinode));
+ di->di_size = cpu_to_be64(sdp->sd_bsize - sizeof(struct gfs2_dinode));
di->di_flags = cpu_to_be32(flags | GFS2_DIF_JDATA);
di->di_payload_format = cpu_to_be32(GFS2_FORMAT_DE);
di->di_entries = cpu_to_be32(2);
@@ -1430,7 +1430,7 @@ 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_size + sdp->bsize - 1) / sdp->bsize;
+ uint64_t dblocks = (ip->i_size + sdp->sd_bsize - 1) / sdp->sd_bsize;
uint64_t ptr0 = ip->i_addr + 1;
unsigned ptrs = 1;
struct gfs2_meta_header mh = {
@@ -1464,7 +1464,7 @@ int lgfs2_write_filemeta(struct gfs2_inode *ip)
start += sizeof(struct gfs2_meta_header);
gfs2_meta_header_out(&mh, bh->b_data);
}
- lgfs2_fill_indir(start, bh->b_data + sdp->bsize, ptr0, ptrs, &p);
+ lgfs2_fill_indir(start, bh->b_data + sdp->sd_bsize, ptr0, ptrs, &p);
if (bwrite(bh)) {
free(bh);
return 1;
@@ -1944,7 +1944,7 @@ int gfs2_freedi(struct gfs2_sbd *sdp, uint64_t diblock)
b_altlist);
for (ptr = (uint64_t *)(bh->b_data + head_size);
- (char *)ptr < (bh->b_data + sdp->bsize); ptr++) {
+ (char *)ptr < (bh->b_data + sdp->sd_bsize); ptr++) {
if (!*ptr)
continue;
diff --git a/gfs2/libgfs2/gfs1.c b/gfs2/libgfs2/gfs1.c
index d1b54a92..4cdf26e5 100644
--- a/gfs2/libgfs2/gfs1.c
+++ b/gfs2/libgfs2/gfs1.c
@@ -93,7 +93,7 @@ void gfs1_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
return;
}
- bsize = (fs_is_jdata(ip)) ? sdp->sd_jbsize : sdp->bsize;
+ bsize = (fs_is_jdata(ip)) ? sdp->sd_jbsize : sdp->sd_bsize;
height = calc_tree_height(ip, (lblock + 1) * bsize);
if (ip->i_height < height) {
@@ -180,15 +180,15 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
return 0;
if (!ip->i_height && /* stuffed */
- ((start + size) > (sdp->bsize - sizeof(struct gfs_dinode))))
+ ((start + size) > (sdp->sd_bsize - sizeof(struct gfs_dinode))))
unstuff_dinode(ip);
if (journaled) {
lblock = offset / sdp->sd_jbsize;
offset %= sdp->sd_jbsize;
} else {
- lblock = offset >> sdp->sd_sb.sb_bsize_shift;
- offset &= sdp->bsize - 1;
+ lblock = offset >> sdp->sd_bsize_shift;
+ offset &= sdp->sd_bsize - 1;
}
if (!ip->i_height) /* stuffed */
@@ -198,8 +198,8 @@ int gfs1_writei(struct gfs2_inode *ip, char *buf, uint64_t offset,
while (copied < size) {
amount = size - copied;
- if (amount > sdp->bsize - offset)
- amount = sdp->bsize - offset;
+ if (amount > sdp->sd_bsize - offset)
+ amount = sdp->sd_bsize - offset;
if (!extlen){
new = 1;
@@ -297,7 +297,7 @@ struct gfs2_inode *lgfs2_gfs_inode_read(struct gfs2_sbd *sdp, uint64_t
di_addr)
bh = bget(sdp, di_addr);
if (bh == NULL)
return NULL;
- if (pread(sdp->device_fd, bh->b_data, sdp->bsize, di_addr * sdp->bsize) !=
sdp->bsize) {
+ if (pread(sdp->device_fd, bh->b_data, sdp->sd_bsize, di_addr *
sdp->sd_bsize) != sdp->sd_bsize) {
brelse(bh);
return NULL;
}
diff --git a/gfs2/libgfs2/gfs2l.c b/gfs2/libgfs2/gfs2l.c
index e582a193..2872d70e 100644
--- a/gfs2/libgfs2/gfs2l.c
+++ b/gfs2/libgfs2/gfs2l.c
@@ -111,7 +111,7 @@ static int openfs(const char *path, struct gfs2_sbd *sdp)
}
memset(sdp, 0, sizeof(*sdp));
- sdp->bsize = GFS2_BASIC_BLOCK;
+ sdp->sd_bsize = GFS2_BASIC_BLOCK;
sdp->device_fd = fd;
ret = compute_constants(sdp);
if (ret != 0) {
@@ -131,7 +131,7 @@ static int openfs(const char *path, struct gfs2_sbd *sdp)
return 1;
}
- sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
gfs2_lookupi(sdp->master_dir, "rindex", 6, &sdp->md.riinode);
sdp->fssize = sdp->device.length;
if (sdp->md.riinode) {
diff --git a/gfs2/libgfs2/lang.c b/gfs2/libgfs2/lang.c
index 3387df57..3633c7a7 100644
--- a/gfs2/libgfs2/lang.c
+++ b/gfs2/libgfs2/lang.c
@@ -158,7 +158,7 @@ static uint64_t ast_lookup_path(char *path, struct gfs2_sbd *sbd)
uint64_t bn = 0;
segment = strtok_r(path, "/", &c);
- ip = lgfs2_inode_read(sbd, sbd->sd_sb.sb_root_dir.no_addr);
+ ip = lgfs2_inode_read(sbd, sbd->sd_root_dir.no_addr);
while (ip != NULL) {
if (segment == NULL) { // No more segments
@@ -215,10 +215,10 @@ static uint64_t ast_lookup_id(const char *id, struct gfs2_sbd *sbd)
bn = LGFS2_SB_ADDR(sbd);
break;
case ID_MASTER:
- bn = sbd->sd_sb.sb_master_dir.no_addr;
+ bn = sbd->sd_meta_dir.no_addr;
break;
case ID_ROOT:
- bn = sbd->sd_sb.sb_root_dir.no_addr;
+ bn = sbd->sd_root_dir.no_addr;
break;
case ID_RINDEX:
bn = sbd->md.riinode->i_addr;
@@ -438,7 +438,7 @@ static struct lgfs2_lang_result *ast_interp_get(struct
lgfs2_lang_state *state,
free(result);
return NULL;
}
- result->lr_buf = lang_read_block(sbd->device_fd, sbd->bsize,
result->lr_blocknr);
+ result->lr_buf = lang_read_block(sbd->device_fd, sbd->sd_bsize,
result->lr_blocknr);
if (result->lr_buf == NULL) {
free(result);
return NULL;
@@ -539,7 +539,7 @@ static struct lgfs2_lang_result *ast_interp_set(struct
lgfs2_lang_state *state,
result->lr_blocknr = ast_lookup_block(lookup, sbd);
if (result->lr_blocknr == 0)
goto out_err;
- result->lr_buf = lang_read_block(sbd->device_fd, sbd->bsize,
result->lr_blocknr);
+ result->lr_buf = lang_read_block(sbd->device_fd, sbd->sd_bsize,
result->lr_blocknr);
if (result->lr_buf == NULL)
goto out_err;
@@ -580,7 +580,7 @@ static struct lgfs2_lang_result *ast_interp_set(struct
lgfs2_lang_state *state,
}
}
- ret = lang_write_result(sbd->device_fd, sbd->bsize, result);
+ ret = lang_write_result(sbd->device_fd, sbd->sd_bsize, result);
if (ret != 0)
goto out_err;
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index f3d4ee78..49250fab 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -302,12 +302,25 @@ struct master_dir
#define LGFS2_SB_ADDR(sdp) (GFS2_SB_ADDR >> (sdp)->sd_fsb2bb_shift)
struct gfs2_sbd {
- struct gfs2_sb sd_sb; /* a copy of the ondisk structure */
-
- unsigned int bsize; /* The block size of the FS (in bytes) */
- unsigned int jsize; /* Size of journals (in MB) */
- unsigned int rgsize; /* Size of resource groups (in MB) */
- unsigned int qcsize; /* Size of quota change files (in MB) */
+ /* CPU-endian counterparts to the on-disk superblock fields */
+ uint32_t sd_bsize;
+ uint32_t sd_fs_format;
+ uint32_t sd_multihost_format;
+ uint32_t sd_flags; /* gfs1 */
+ struct {
+ uint64_t no_formal_ino;
+ uint64_t no_addr;
+ } sd_meta_dir,
+ sd_root_dir,
+ sd_rindex_di, /* gfs1 */
+ sd_jindex_di, /* gfs1 */
+ sd_quota_di, /* gfs1 */
+ sd_license_di; /* gfs1 */
+ uint32_t sd_bsize_shift;
+ uint32_t sd_seg_size;
+ char sd_lockproto[GFS2_LOCKNAME_LEN];
+ char sd_locktable[GFS2_LOCKNAME_LEN];
+ uint8_t sd_uuid[16];
/* Constants */
@@ -326,7 +339,9 @@ struct gfs2_sbd {
uint64_t sd_heightsize[GFS2_MAX_META_HEIGHT];
uint64_t sd_jheightsize[GFS2_MAX_META_HEIGHT];
- /* Not specified on the command line, but... */
+ unsigned int jsize; /* Size of journals (in MB) */
+ unsigned int rgsize; /* Size of resource groups (in MB) */
+ unsigned int qcsize; /* Size of quota change files (in MB) */
int64_t time;
@@ -731,8 +746,7 @@ static inline unsigned int rgrp_size(struct rgrp_tree *rgrp)
/* structures.c */
extern int build_master(struct gfs2_sbd *sdp);
-extern void lgfs2_sb_init(struct gfs2_sb *sb, unsigned bsize, unsigned format);
-extern int lgfs2_sb_write(const struct gfs2_sb *sb, int fd, const unsigned bsize);
+extern int lgfs2_sb_write(const struct gfs2_sbd *sdp, int fd);
extern int build_journal(struct gfs2_sbd *sdp, int j,
struct gfs2_inode *jindex);
extern int build_jindex(struct gfs2_sbd *sdp);
@@ -753,7 +767,7 @@ extern int build_statfs_change(struct gfs2_inode *per_node, unsigned
int j);
extern int build_quota_change(struct gfs2_inode *per_node, unsigned int j);
/* super.c */
-extern int check_sb(struct gfs2_sb *sb);
+extern int check_sb(void *sbp);
extern int read_sb(struct gfs2_sbd *sdp);
extern int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount, int *ok);
extern int write_sb(struct gfs2_sbd *sdp);
@@ -769,8 +783,8 @@ extern void gfs2_inum_in(struct gfs2_inum *no, char *buf);
extern void gfs2_inum_out(const struct gfs2_inum *no, char *buf);
extern void gfs2_meta_header_in(struct gfs2_meta_header *mh, const char *buf);
extern void gfs2_meta_header_out(const struct gfs2_meta_header *mh, char *buf);
-extern void gfs2_sb_in(struct gfs2_sb *sb, char *buf);
-extern void gfs2_sb_out(const struct gfs2_sb *sb, char *buf);
+extern void lgfs2_sb_in(struct gfs2_sbd *sdp, void *buf);
+extern void lgfs2_sb_out(const struct gfs2_sbd *sdp, void *buf);
extern void lgfs2_rindex_in(lgfs2_rgrp_t rg, void *buf);
extern void lgfs2_rindex_out(const lgfs2_rgrp_t rg, void *buf);
extern void lgfs2_rgrp_in(lgfs2_rgrp_t rg, void *buf);
diff --git a/gfs2/libgfs2/misc.c b/gfs2/libgfs2/misc.c
index 6dfd9afb..f2bab8ef 100644
--- a/gfs2/libgfs2/misc.c
+++ b/gfs2/libgfs2/misc.c
@@ -43,19 +43,19 @@ int compute_constants(struct gfs2_sbd *sdp)
sdp->md.next_inum = 1;
- sdp->sd_sb.sb_bsize_shift = ffs(sdp->bsize) - 1;
- sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
+ sdp->sd_bsize_shift = ffs(sdp->sd_bsize) - 1;
+ sdp->sd_fsb2bb_shift = sdp->sd_bsize_shift -
GFS2_BASIC_BLOCK_SHIFT;
sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
- sdp->sd_diptrs = (sdp->bsize - sizeof(struct gfs2_dinode)) /
+ sdp->sd_diptrs = (sdp->sd_bsize - sizeof(struct gfs2_dinode)) /
sizeof(uint64_t);
- sdp->sd_inptrs = (sdp->bsize - sizeof(struct gfs2_meta_header)) /
+ sdp->sd_inptrs = (sdp->sd_bsize - sizeof(struct gfs2_meta_header)) /
sizeof(uint64_t);
- sdp->sd_jbsize = sdp->bsize - sizeof(struct gfs2_meta_header);
- sdp->sd_hash_bsize = sdp->bsize / 2;
- sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
+ sdp->sd_jbsize = sdp->sd_bsize - sizeof(struct gfs2_meta_header);
+ sdp->sd_hash_bsize = sdp->sd_bsize / 2;
+ sdp->sd_hash_bsize_shift = sdp->sd_bsize_shift - 1;
sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(uint64_t);
- sdp->sd_blocks_per_bitmap = (sdp->sd_sb.sb_bsize - sizeof(struct
gfs2_meta_header))
+ sdp->sd_blocks_per_bitmap = (sdp->sd_bsize - sizeof(struct gfs2_meta_header))
* GFS2_NBBY;
/* Compute maximum reservation required to add a entry to a directory */
@@ -73,11 +73,11 @@ int compute_constants(struct gfs2_sbd *sdp)
sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;
- if (compute_heightsize(sdp->bsize, sdp->sd_heightsize,
&sdp->sd_max_height,
- sdp->bsize, sdp->sd_diptrs, sdp->sd_inptrs)) {
+ if (compute_heightsize(sdp->sd_bsize, sdp->sd_heightsize,
&sdp->sd_max_height,
+ sdp->sd_bsize, sdp->sd_diptrs, sdp->sd_inptrs)) {
return -1;
}
- if (compute_heightsize(sdp->bsize, sdp->sd_jheightsize,
&sdp->sd_max_jheight,
+ if (compute_heightsize(sdp->sd_bsize, sdp->sd_jheightsize,
&sdp->sd_max_jheight,
sdp->sd_jbsize, sdp->sd_diptrs, sdp->sd_inptrs)) {
return -1;
}
diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c
index 3fe8aa0a..a1805234 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -117,54 +117,57 @@ void lgfs2_meta_header_print(void *mhp)
printbe32(mh, mh_format);
}
-void gfs2_sb_in(struct gfs2_sb *sb, char *buf)
+void lgfs2_sb_in(struct gfs2_sbd *sdp, void *buf)
{
- struct gfs2_sb *str = (struct gfs2_sb *)buf;
-
- gfs2_meta_header_in(&sb->sb_header, buf);
-
- CPIN_32(sb, str, sb_fs_format);
- CPIN_32(sb, str, sb_multihost_format);
- CPIN_32(sb, str, __pad0); /* gfs sb_flags */
-
- CPIN_32(sb, str, sb_bsize);
- CPIN_32(sb, str, sb_bsize_shift);
- CPIN_32(sb, str, __pad1); /* gfs sb_seg_size */
-
- gfs2_inum_in(&sb->sb_master_dir, (char *)&str->sb_master_dir);
- gfs2_inum_in(&sb->sb_root_dir, (char *)&str->sb_root_dir);
-
- CPIN_08(sb, str, sb_lockproto, GFS2_LOCKNAME_LEN);
- CPIN_08(sb, str, sb_locktable, GFS2_LOCKNAME_LEN);
- gfs2_inum_in(&sb->__pad2, (char *)&str->__pad2); /* gfs rindex */
- gfs2_inum_in(&sb->__pad3, (char *)&str->__pad3); /* gfs quota */
- gfs2_inum_in(&sb->__pad4, (char *)&str->__pad4); /* gfs license */
- CPIN_08(sb, str, sb_uuid, sizeof(sb->sb_uuid));
+ struct gfs2_sb *sb = buf;
+
+ sdp->sd_fs_format = be32_to_cpu(sb->sb_fs_format);
+ sdp->sd_multihost_format = be32_to_cpu(sb->sb_multihost_format);
+ sdp->sd_flags = be32_to_cpu(sb->__pad0);
+ sdp->sd_bsize = be32_to_cpu(sb->sb_bsize);
+ sdp->sd_bsize_shift = be32_to_cpu(sb->sb_bsize_shift);
+ sdp->sd_seg_size = be32_to_cpu(sb->__pad1);
+ sdp->sd_meta_dir.no_formal_ino = be64_to_cpu(sb->sb_master_dir.no_formal_ino);
+ sdp->sd_meta_dir.no_addr = be64_to_cpu(sb->sb_master_dir.no_addr);
+ sdp->sd_root_dir.no_formal_ino = be64_to_cpu(sb->sb_root_dir.no_formal_ino);
+ sdp->sd_root_dir.no_addr = be64_to_cpu(sb->sb_root_dir.no_addr);
+ memcpy(sdp->sd_lockproto, sb->sb_lockproto, GFS2_LOCKNAME_LEN);
+ memcpy(sdp->sd_locktable, sb->sb_locktable, GFS2_LOCKNAME_LEN);
+ sdp->sd_rindex_di.no_formal_ino = be64_to_cpu(sb->__pad2.no_formal_ino);
+ sdp->sd_rindex_di.no_addr = be64_to_cpu(sb->__pad2.no_addr);
+ sdp->sd_quota_di.no_formal_ino = be64_to_cpu(sb->__pad3.no_formal_ino);
+ sdp->sd_quota_di.no_addr = be64_to_cpu(sb->__pad3.no_addr);
+ sdp->sd_license_di.no_formal_ino = be64_to_cpu(sb->__pad4.no_formal_ino);
+ sdp->sd_license_di.no_addr = be64_to_cpu(sb->__pad4.no_addr);
+ memcpy(sdp->sd_uuid, sb->sb_uuid, sizeof(sdp->sd_uuid));
}
-void gfs2_sb_out(const struct gfs2_sb *sb, char *buf)
+void lgfs2_sb_out(const struct gfs2_sbd *sdp, void *buf)
{
- struct gfs2_sb *str = (struct gfs2_sb *)buf;
-
- gfs2_meta_header_out(&sb->sb_header, buf);
-
- CPOUT_32(sb, str, sb_fs_format);
- CPOUT_32(sb, str, sb_multihost_format);
- CPOUT_32(sb, str, __pad0); /* gfs sb_flags */
-
- CPOUT_32(sb, str, sb_bsize);
- CPOUT_32(sb, str, sb_bsize_shift);
- CPOUT_32(sb, str, __pad1); /* gfs sb_seg_size */
-
- gfs2_inum_out(&sb->sb_master_dir, (char *)&str->sb_master_dir);
- gfs2_inum_out(&sb->sb_root_dir, (char *)&str->sb_root_dir);
-
- CPOUT_08(sb, str, sb_lockproto, GFS2_LOCKNAME_LEN);
- CPOUT_08(sb, str, sb_locktable, GFS2_LOCKNAME_LEN);
- gfs2_inum_out(&sb->__pad2, (char *)&str->__pad2); /* gfs rindex */
- gfs2_inum_out(&sb->__pad3, (char *)&str->__pad3); /* gfs quota */
- gfs2_inum_out(&sb->__pad4, (char *)&str->__pad4); /* gfs license */
- memcpy(str->sb_uuid, sb->sb_uuid, 16);
+ struct gfs2_sb *sb = buf;
+
+ sb->sb_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
+ sb->sb_header.mh_type = cpu_to_be32(GFS2_METATYPE_SB);
+ sb->sb_header.mh_format = cpu_to_be32(GFS2_FORMAT_SB);
+ sb->sb_fs_format = cpu_to_be32(sdp->sd_fs_format);
+ sb->sb_multihost_format = cpu_to_be32(sdp->sd_multihost_format);
+ sb->__pad0 = cpu_to_be32(sdp->sd_flags);
+ sb->sb_bsize = cpu_to_be32(sdp->sd_bsize);
+ sb->sb_bsize_shift = cpu_to_be32(sdp->sd_bsize_shift);
+ sb->__pad1 = cpu_to_be32(sdp->sd_seg_size);
+ sb->sb_master_dir.no_formal_ino = cpu_to_be64(sdp->sd_meta_dir.no_formal_ino);
+ sb->sb_master_dir.no_addr = cpu_to_be64(sdp->sd_meta_dir.no_addr);
+ sb->sb_root_dir.no_formal_ino = cpu_to_be64(sdp->sd_root_dir.no_formal_ino);
+ sb->sb_root_dir.no_addr = cpu_to_be64(sdp->sd_root_dir.no_addr);
+ memcpy(sb->sb_lockproto, sdp->sd_lockproto, GFS2_LOCKNAME_LEN);
+ memcpy(sb->sb_locktable, sdp->sd_locktable, GFS2_LOCKNAME_LEN);
+ sb->__pad2.no_formal_ino = cpu_to_be64(sdp->sd_rindex_di.no_formal_ino);
+ sb->__pad2.no_addr = cpu_to_be64(sdp->sd_rindex_di.no_addr);
+ sb->__pad3.no_formal_ino = cpu_to_be64(sdp->sd_quota_di.no_formal_ino);
+ sb->__pad3.no_addr = cpu_to_be64(sdp->sd_quota_di.no_addr);
+ sb->__pad4.no_formal_ino = cpu_to_be64(sdp->sd_license_di.no_formal_ino);
+ sb->__pad4.no_addr = cpu_to_be64(sdp->sd_license_di.no_addr);
+ memcpy(sb->sb_uuid, sdp->sd_uuid, 16);
}
void lgfs2_sb_print(void *sbp)
diff --git a/gfs2/libgfs2/recovery.c b/gfs2/libgfs2/recovery.c
index 7c445f15..9234a867 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_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_bsize;
if (++*blk == jd_blocks)
*blk = 0;
@@ -85,7 +85,7 @@ int lgfs2_get_log_header(struct gfs2_inode *ip, unsigned int blk,
tmp->lh_hash = 0;
hash = lgfs2_log_header_hash(bh->b_data);
tmp->lh_hash = saved_hash;
- crc = lgfs2_log_header_crc(bh->b_data, ip->i_sbd->bsize);
+ crc = lgfs2_log_header_crc(bh->b_data, ip->i_sbd->sd_bsize);
log_header_in(&lh, bh->b_data);
brelse(bh);
lh_crc = lh.lh_crc;
@@ -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_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_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_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_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_size / ip->i_sbd->sd_sb.sb_bsize;
+ uint32_t jd_blocks = ip->i_size / ip->i_sbd->sd_bsize;
int error;
blk_1 = 0;
@@ -245,7 +245,7 @@ int lgfs2_clean_journal(struct gfs2_inode *ip, struct lgfs2_log_header
*head)
return -EIO;
bh = bread(ip->i_sbd, dblock);
- memset(bh->b_data, 0, ip->i_sbd->bsize);
+ memset(bh->b_data, 0, ip->i_sbd->sd_bsize);
lh = (struct gfs2_log_header *)bh->b_data;
memset(lh, 0, sizeof(struct gfs2_log_header));
diff --git a/gfs2/libgfs2/rgrp.c b/gfs2/libgfs2/rgrp.c
index 96789ff4..454f6e60 100644
--- a/gfs2/libgfs2/rgrp.c
+++ b/gfs2/libgfs2/rgrp.c
@@ -109,14 +109,14 @@ struct rgrp_tree *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, uint64_t
blk)
int lgfs2_rgrp_bitbuf_alloc(lgfs2_rgrp_t rg)
{
struct gfs2_sbd *sdp = rg->rgrps->sdp;
- size_t len = rg->rt_length * sdp->bsize;
- unsigned long io_align = sdp->bsize;
+ size_t len = rg->rt_length * sdp->sd_bsize;
+ unsigned long io_align = sdp->sd_bsize;
unsigned i;
char *bufs;
if (rg->rgrps->align > 0) {
- len = ROUND_UP(len, rg->rgrps->align * sdp->bsize);
- io_align = rg->rgrps->align_off * sdp->bsize;
+ len = ROUND_UP(len, rg->rgrps->align * sdp->sd_bsize);
+ io_align = rg->rgrps->align_off * sdp->sd_bsize;
}
if (posix_memalign((void **)&bufs, io_align, len) != 0) {
errno = ENOMEM;
@@ -125,7 +125,7 @@ int lgfs2_rgrp_bitbuf_alloc(lgfs2_rgrp_t rg)
memset(bufs, 0, len);
for (i = 0; i < rg->rt_length; i++) {
- rg->bits[i].bi_data = bufs + (i * sdp->bsize);
+ rg->bits[i].bi_data = bufs + (i * sdp->sd_bsize);
rg->bits[i].bi_modified = 0;
}
return 0;
@@ -189,8 +189,8 @@ void lgfs2_rgrp_crc_set(char *buf)
*/
uint64_t gfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
{
- unsigned length = rgd->rt_length * sdp->bsize;
- off_t offset = rgd->rt_addr * sdp->bsize;
+ unsigned length = rgd->rt_length * sdp->sd_bsize;
+ off_t offset = rgd->rt_addr * sdp->sd_bsize;
char *buf;
if (length == 0 || gfs2_check_range(sdp, rgd->rt_addr))
@@ -208,7 +208,7 @@ uint64_t gfs2_rgrp_read(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
for (unsigned i = 0; i < rgd->rt_length; i++) {
int mtype = (i ? GFS2_METATYPE_RB : GFS2_METATYPE_RG);
- rgd->bits[i].bi_data = buf + (i * sdp->bsize);
+ rgd->bits[i].bi_data = buf + (i * sdp->sd_bsize);
if (gfs2_check_meta(rgd->bits[i].bi_data, mtype)) {
free(buf);
rgd->bits[0].bi_data = NULL;
@@ -232,14 +232,14 @@ void gfs2_rgrp_relse(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
if (rgd->bits == NULL)
return;
for (unsigned i = 0; i < rgd->rt_length; i++) {
- off_t offset = sdp->bsize * (rgd->rt_addr + i);
+ off_t offset = sdp->sd_bsize * (rgd->rt_addr + i);
ssize_t ret;
if (rgd->bits[i].bi_data == NULL || !rgd->bits[i].bi_modified)
continue;
- ret = pwrite(sdp->device_fd, rgd->bits[i].bi_data, sdp->bsize, offset);
- if (ret != sdp->bsize) {
+ ret = pwrite(sdp->device_fd, rgd->bits[i].bi_data, sdp->sd_bsize, offset);
+ if (ret != sdp->sd_bsize) {
fprintf(stderr, "Failed to write modified resource group at block
%"PRIu64": %s\n",
rgd->rt_addr, strerror(errno));
}
@@ -344,8 +344,8 @@ uint32_t lgfs2_rgrp_align_len(const lgfs2_rgrps_t rgs, uint32_t len)
*/
uint32_t lgfs2_rgrps_plan(const lgfs2_rgrps_t rgs, uint64_t space, uint32_t tgtsize)
{
- uint32_t maxlen = (GFS2_MAX_RGSIZE << 20) / rgs->sdp->bsize;
- uint32_t minlen = (GFS2_MIN_RGSIZE << 20) / rgs->sdp->bsize;
+ uint32_t maxlen = (GFS2_MAX_RGSIZE << 20) / rgs->sdp->sd_bsize;
+ uint32_t minlen = (GFS2_MIN_RGSIZE << 20) / rgs->sdp->sd_bsize;
struct rg_spec *spec = rgs->plan->rg_specs;
/* Apps should already have checked that the rg size is <=
@@ -579,7 +579,7 @@ uint64_t lgfs2_rindex_entry_new(lgfs2_rgrps_t rgs, struct gfs2_rindex
*ri, uint6
if (addr + len > rgs->sdp->device.length)
return 0;
- ri_length = rgblocks2bitblocks(rgs->sdp->bsize, len, &ri_data);
+ ri_length = rgblocks2bitblocks(rgs->sdp->sd_bsize, len, &ri_data);
ri->ri_addr = cpu_to_be64(addr);
ri->ri_length = cpu_to_be32(ri_length);
ri->ri_data = cpu_to_be32(ri_data);
@@ -654,7 +654,7 @@ lgfs2_rgrp_t lgfs2_rgrps_append(lgfs2_rgrps_t rgs, struct gfs2_rindex
*entry, ui
rg->rt_dinodes = 0;
rg->rt_skip = rg_skip;
rg->rt_igeneration = 0;
- compute_bitmaps(rg, rgs->sdp->bsize);
+ compute_bitmaps(rg, rgs->sdp->sd_bsize);
rg->rgrps = rgs;
return rg;
}
@@ -685,11 +685,11 @@ int lgfs2_rgrp_write(int fd, const lgfs2_rgrp_t rg)
mh->mh_format = cpu_to_be32(GFS2_FORMAT_RB);
}
- len = sdp->bsize * rg->rt_length;
+ len = sdp->sd_bsize * rg->rt_length;
if (rg->rgrps->align > 0)
- len = ROUND_UP(len, rg->rgrps->align * sdp->bsize);
+ len = ROUND_UP(len, rg->rgrps->align * sdp->sd_bsize);
- ret = pwrite(fd, rg->bits[0].bi_data, len, rg->rt_addr * sdp->bsize);
+ ret = pwrite(fd, rg->bits[0].bi_data, len, rg->rt_addr * sdp->sd_bsize);
if (freebufs)
lgfs2_rgrp_bitbuf_free(rg);
@@ -891,7 +891,7 @@ static uint32_t lgfs2_free_extlen(const struct lgfs2_rbm *rrbm,
uint32_t len)
while (len > 3) {
bi = rbm_bi(&rbm);
start = (uint8_t *)bi->bi_data;
- end = start + sdp->bsize;
+ end = start + sdp->sd_bsize;
start += bi->bi_offset;
start += (rbm.offset / GFS2_NBBY);
bytes = (len / GFS2_NBBY) < (end - start) ? (len / GFS2_NBBY):(end - start);
diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c
index e900a7df..0957e5ad 100644
--- a/gfs2/libgfs2/structures.c
+++ b/gfs2/libgfs2/structures.c
@@ -46,31 +46,15 @@ int build_master(struct gfs2_sbd *sdp)
return 0;
}
-/**
- * Initialise a gfs2_sb structure with sensible defaults.
- */
-void lgfs2_sb_init(struct gfs2_sb *sb, unsigned bsize, unsigned format)
-{
- memset(sb, 0, sizeof(struct gfs2_sb));
- sb->sb_header.mh_magic = GFS2_MAGIC;
- sb->sb_header.mh_type = GFS2_METATYPE_SB;
- sb->sb_header.mh_format = GFS2_FORMAT_SB;
- sb->sb_fs_format = format;
- sb->sb_multihost_format = GFS2_FORMAT_MULTI;
- sb->sb_bsize = bsize;
- sb->sb_bsize_shift = ffs(bsize) - 1;
- uuid_generate(sb->sb_uuid);
-}
-
-int lgfs2_sb_write(const struct gfs2_sb *sb, int fd, const unsigned bsize)
+int lgfs2_sb_write(const struct gfs2_sbd *sdp, int fd)
{
int i, err = -1;
struct iovec *iov;
- const size_t sb_addr = GFS2_SB_ADDR * GFS2_BASIC_BLOCK / bsize;
+ const size_t sb_addr = GFS2_SB_ADDR * GFS2_BASIC_BLOCK / sdp->sd_bsize;
const size_t len = sb_addr + 1;
/* We only need 2 blocks: one for zeroing and a second for the superblock */
- char *buf = calloc(2, bsize);
+ char *buf = calloc(2, sdp->sd_bsize);
if (buf == NULL)
return -1;
@@ -80,13 +64,13 @@ int lgfs2_sb_write(const struct gfs2_sb *sb, int fd, const unsigned
bsize)
for (i = 0; i < len; i++) {
iov[i].iov_base = buf;
- iov[i].iov_len = bsize;
+ iov[i].iov_len = sdp->sd_bsize;
}
- gfs2_sb_out(sb, buf + bsize);
- iov[sb_addr].iov_base = buf + bsize;
+ lgfs2_sb_out(sdp, buf + sdp->sd_bsize);
+ iov[sb_addr].iov_base = buf + sdp->sd_bsize;
- if (pwritev(fd, iov, len, 0) < (len * bsize))
+ if (pwritev(fd, iov, len, 0) < (len * sdp->sd_bsize))
goto out_iov;
err = 0;
@@ -125,14 +109,14 @@ 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_size + sdp->bsize - 1) / sdp->bsize;
+ unsigned blocks = (ip->i_size + sdp->sd_bsize - 1) / sdp->sd_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;
char *buf;
- buf = calloc(1, sdp->bsize);
+ buf = calloc(1, sdp->sd_bsize);
if (buf == NULL)
return -1;
@@ -152,10 +136,10 @@ int lgfs2_write_journal_data(struct gfs2_inode *ip)
hash = lgfs2_log_header_hash(buf);
lh->lh_hash = cpu_to_be32(hash);
lh->lh_addr = cpu_to_be64(jblk);
- hash = lgfs2_log_header_crc(buf, sdp->bsize);
+ hash = lgfs2_log_header_crc(buf, sdp->sd_bsize);
lh->lh_crc = cpu_to_be32(hash);
- if (pwrite(sdp->device_fd, buf, sdp->bsize, jblk * sdp->bsize) !=
sdp->bsize) {
+ if (pwrite(sdp->device_fd, buf, sdp->sd_bsize, jblk * sdp->sd_bsize) !=
sdp->sd_bsize) {
free(buf);
return -1;
}
@@ -186,9 +170,9 @@ static struct gfs2_buffer_head *get_file_buf(struct gfs2_inode *ip,
uint64_t lbn
return NULL;
if (!prealloc && new &&
- ip->i_size < (lbn + 1) << sdp->sd_sb.sb_bsize_shift) {
+ ip->i_size < (lbn + 1) << sdp->sd_bsize_shift) {
bmodified(ip->i_bh);
- ip->i_size = (lbn + 1) << sdp->sd_sb.sb_bsize_shift;
+ ip->i_size = (lbn + 1) << sdp->sd_bsize_shift;
}
if (dbn == ip->i_addr)
return ip->i_bh;
@@ -259,8 +243,8 @@ int build_journal(struct gfs2_sbd *sdp, int j, struct gfs2_inode
*jindex)
if (sdp->md.journal[j] == NULL) {
return errno;
}
- ret = write_journal(sdp->md.journal[j], sdp->bsize,
- sdp->jsize << 20 >> sdp->sd_sb.sb_bsize_shift);
+ ret = write_journal(sdp->md.journal[j], sdp->sd_bsize,
+ sdp->jsize << 20 >> sdp->sd_bsize_shift);
return ret;
}
@@ -387,7 +371,7 @@ int build_quota_change(struct gfs2_inode *per_node, unsigned int j)
struct gfs2_meta_header mh;
char name[256];
struct gfs2_inode *ip;
- unsigned int blocks = sdp->qcsize << (20 - sdp->sd_sb.sb_bsize_shift);
+ unsigned int blocks = sdp->qcsize << (20 - sdp->sd_bsize_shift);
unsigned int x;
unsigned int hgt;
struct gfs2_buffer_head *bh;
@@ -403,7 +387,7 @@ int build_quota_change(struct gfs2_inode *per_node, unsigned int j)
return errno;
}
- hgt = calc_tree_height(ip, (blocks + 1) * sdp->bsize);
+ hgt = calc_tree_height(ip, (blocks + 1) * sdp->sd_bsize);
build_height(ip, hgt);
for (x = 0; x < blocks; x++) {
@@ -411,7 +395,7 @@ int build_quota_change(struct gfs2_inode *per_node, unsigned int j)
if (!bh)
return -1;
- memset(bh->b_data, 0, sdp->bsize);
+ memset(bh->b_data, 0, sdp->sd_bsize);
gfs2_meta_header_out(&mh, bh->b_data);
bmodified(bh);
brelse(bh);
diff --git a/gfs2/libgfs2/super.c b/gfs2/libgfs2/super.c
index f304b4df..cd2a2ecf 100644
--- a/gfs2/libgfs2/super.c
+++ b/gfs2/libgfs2/super.c
@@ -22,22 +22,24 @@
*
* Returns: -1 on failure, 1 if this is gfs (gfs1), 2 if this is gfs2
*/
-int check_sb(struct gfs2_sb *sb)
+int check_sb(void *sbp)
{
- if (sb->sb_header.mh_magic != GFS2_MAGIC ||
- sb->sb_header.mh_type != GFS2_METATYPE_SB) {
+ struct gfs2_sb *sb = sbp;
+
+ if (be32_to_cpu(sb->sb_header.mh_magic) != GFS2_MAGIC ||
+ be32_to_cpu(sb->sb_header.mh_type) != GFS2_METATYPE_SB) {
errno = EIO;
return -1;
}
/* Check for gfs1 */
- if (sb->sb_fs_format == GFS_FORMAT_FS &&
- sb->sb_header.mh_format == GFS_FORMAT_SB &&
- sb->sb_multihost_format == GFS_FORMAT_MULTI) {
+ if (be32_to_cpu(sb->sb_fs_format) == GFS_FORMAT_FS &&
+ be32_to_cpu(sb->sb_header.mh_format) == GFS_FORMAT_SB &&
+ be32_to_cpu(sb->sb_multihost_format) == GFS_FORMAT_MULTI) {
return 1;
}
/* It's gfs2. Check format number is in a sensible range. */
- if (sb->sb_fs_format < LGFS2_FS_FORMAT_MIN ||
- sb->sb_fs_format > 1899) {
+ if (be32_to_cpu(sb->sb_fs_format) < LGFS2_FS_FORMAT_MIN ||
+ be32_to_cpu(sb->sb_fs_format) > 1899) {
errno = EINVAL;
return -1;
}
@@ -64,40 +66,40 @@ int read_sb(struct gfs2_sbd *sdp)
int ret;
bh = bread(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
- gfs2_sb_in(&sdp->sd_sb, bh->b_data);
- brelse(bh);
- ret = check_sb(&sdp->sd_sb);
+ ret = check_sb(bh->b_data);
if (ret < 0)
return ret;
if (ret == 1)
sdp->gfs1 = 1;
- sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift - GFS2_BASIC_BLOCK_SHIFT;
- sdp->bsize = sdp->sd_sb.sb_bsize;
- if (sdp->bsize < 512 || sdp->bsize != (sdp->bsize & -sdp->bsize)) {
+
+ lgfs2_sb_in(sdp, bh->b_data);
+ brelse(bh);
+ sdp->sd_fsb2bb_shift = sdp->sd_bsize_shift - GFS2_BASIC_BLOCK_SHIFT;
+ if (sdp->sd_bsize < 512 || sdp->sd_bsize != (sdp->sd_bsize &
-sdp->sd_bsize)) {
return -1;
}
if (sdp->gfs1) {
- sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
+ sdp->sd_diptrs = (sdp->sd_bsize -
sizeof(struct gfs_dinode)) /
sizeof(uint64_t);
- sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
+ sdp->sd_inptrs = (sdp->sd_bsize -
sizeof(struct gfs_indirect)) /
sizeof(uint64_t);
} else {
- sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
+ sdp->sd_diptrs = (sdp->sd_bsize -
sizeof(struct gfs2_dinode)) /
sizeof(uint64_t);
- sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
+ sdp->sd_inptrs = (sdp->sd_bsize -
sizeof(struct gfs2_meta_header)) /
sizeof(uint64_t);
}
- sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
- sdp->sd_hash_bsize = sdp->bsize / 2;
- sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
+ sdp->sd_jbsize = sdp->sd_bsize - sizeof(struct gfs2_meta_header);
+ sdp->sd_hash_bsize = sdp->sd_bsize / 2;
+ sdp->sd_hash_bsize_shift = sdp->sd_bsize_shift - 1;
sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(uint64_t);
- sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
- sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
+ sdp->sd_heightsize[0] = sdp->sd_bsize - sizeof(struct gfs2_dinode);
+ sdp->sd_heightsize[1] = sdp->sd_bsize * sdp->sd_diptrs;
for (x = 2; x < GFS2_MAX_META_HEIGHT; x++){
space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
/* FIXME: Do we really need this first check?? */
@@ -111,7 +113,7 @@ int read_sb(struct gfs2_sbd *sdp)
return -1;
}
- sdp->sd_jheightsize[0] = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode);
+ sdp->sd_jheightsize[0] = sdp->sd_bsize - sizeof(struct gfs2_dinode);
sdp->sd_jheightsize[1] = sdp->sd_jbsize * sdp->sd_diptrs;
for (x = 2; ; x++){
space = sdp->sd_jheightsize[x - 1] * sdp->sd_inptrs;
@@ -125,8 +127,8 @@ int read_sb(struct gfs2_sbd *sdp)
errno = E2BIG;
return -1;
}
- sdp->fssize = lseek(sdp->device_fd, 0, SEEK_END) / sdp->sd_sb.sb_bsize;
- sdp->sd_blocks_per_bitmap = (sdp->sd_sb.sb_bsize - sizeof(struct
gfs2_meta_header))
+ sdp->fssize = lseek(sdp->device_fd, 0, SEEK_END) / sdp->sd_bsize;
+ sdp->sd_blocks_per_bitmap = (sdp->sd_bsize - sizeof(struct gfs2_meta_header))
* GFS2_NBBY;
sdp->qcsize = GFS2_DEFAULT_QCSIZE;
@@ -153,7 +155,7 @@ static int rgd_seems_ok(struct gfs2_sbd *sdp, struct rgrp_tree *rgd)
/* A max rgrp, 2GB, divided into blocksize, divided by blocks/byte
represented in the bitmap, NBBY. Rough approximation only, due to
metadata headers. I'm doing the math this way to avoid overflow. */
- most_bitmaps_possible = (GFS2_MAX_RGSIZE * 1024 * 256) / sdp->bsize;
+ most_bitmaps_possible = (GFS2_MAX_RGSIZE * 1024 * 256) / sdp->sd_bsize;
if (rgd->rt_length > most_bitmaps_possible)
return 0;
@@ -247,7 +249,7 @@ int rindex_read(struct gfs2_sbd *sdp, uint64_t *rgcount, int *ok)
prev_rgd->length = rgrp_size(prev_rgd);
}
- if(gfs2_compute_bitstructs(sdp->sd_sb.sb_bsize, rgd))
+ if(gfs2_compute_bitstructs(sdp->sd_bsize, rgd))
*ok = 0;
(*rgcount)++;
diff --git a/gfs2/mkfs/main_grow.c b/gfs2/mkfs/main_grow.c
index deb9230d..8204d263 100644
--- a/gfs2/mkfs/main_grow.c
+++ b/gfs2/mkfs/main_grow.c
@@ -174,8 +174,8 @@ static lgfs2_rgrps_t rgrps_init(struct gfs2_sbd *sdp)
if ((min_io_sz > phy_sector_sz) &&
(opt_io_sz > phy_sector_sz) &&
(opt_io_sz % min_io_sz == 0)) {
- al_base = opt_io_sz / sdp->bsize;
- al_off = min_io_sz / sdp->bsize;
+ al_base = opt_io_sz / sdp->sd_bsize;
+ al_off = min_io_sz / sdp->sd_bsize;
}
}
@@ -208,7 +208,7 @@ static unsigned initialize_new_portion(struct gfs2_sbd *sdp,
lgfs2_rgrps_t rgs)
unsigned rgcount = 0;
uint64_t rgaddr = fssize;
- discard_blocks(sdp->device_fd, rgaddr * sdp->bsize, fsgrowth * sdp->bsize);
+ discard_blocks(sdp->device_fd, rgaddr * sdp->sd_bsize, fsgrowth *
sdp->sd_bsize);
/* Build the remaining resource groups */
while (1) {
int err = 0;
@@ -332,7 +332,7 @@ static void print_info(struct gfs2_sbd *sdp, char *device, char
*mnt_path)
(unsigned long long)sdp->device.length,
(unsigned long long)sdp->device.length);
log_notice(_("The file system will grow by %lluMB.\n"),
- (unsigned long long)(fsgrowth * sdp->bsize) / MB);
+ (unsigned long long)(fsgrowth * sdp->sd_bsize) / MB);
}
static int open_rindex(char *metafs_path, int mode)
@@ -366,7 +366,7 @@ int main(int argc, char *argv[])
srandom(time(NULL) ^ getpid());
memset(sdp, 0, sizeof(struct gfs2_sbd));
- sdp->bsize = GFS2_DEFAULT_BSIZE;
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
sdp->rgsize = -1;
sdp->jsize = GFS2_DEFAULT_JSIZE;
sdp->qcsize = GFS2_DEFAULT_QCSIZE;
@@ -395,8 +395,8 @@ int main(int argc, char *argv[])
perror(mnt->mnt_fsname);
exit(EXIT_FAILURE);
}
- sdp->sd_sb.sb_bsize = GFS2_DEFAULT_BSIZE;
- sdp->bsize = sdp->sd_sb.sb_bsize;
+ sdp->sd_bsize = GFS2_DEFAULT_BSIZE;
+ sdp->sd_bsize = sdp->sd_bsize;
if (compute_constants(sdp)) {
log_crit("%s\n", _("Failed to compute file system constants"));
exit(EXIT_FAILURE);
@@ -421,7 +421,7 @@ int main(int argc, char *argv[])
exit(EXIT_FAILURE);
}
/* Get master dinode */
- sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
if (sdp->master_dir == NULL) {
perror(_("Could not read master directory"));
exit(EXIT_FAILURE);
@@ -457,7 +457,7 @@ int main(int argc, char *argv[])
goto out;
}
fsgrowth = (sdp->device.length - fssize);
- rgcount = lgfs2_rgrps_plan(rgs, fsgrowth, ((GFS2_MAX_RGSIZE << 20) /
sdp->bsize));
+ rgcount = lgfs2_rgrps_plan(rgs, fsgrowth, ((GFS2_MAX_RGSIZE << 20) /
sdp->sd_bsize));
if (rgcount == 0) {
log_err( _("The calculated resource group size is too small.\n"));
log_err( _("%s has not grown.\n"), argv[optind]);
diff --git a/gfs2/mkfs/main_jadd.c b/gfs2/mkfs/main_jadd.c
index 8e349c9c..66d9e293 100644
--- a/gfs2/mkfs/main_jadd.c
+++ b/gfs2/mkfs/main_jadd.c
@@ -350,9 +350,9 @@ close_fd:
static int add_qc(struct gfs2_sbd *sdp, struct jadd_opts *opts)
{
int fd, error = 0;
- char new_name[256], buf[sdp->bsize];
+ char new_name[256], buf[sdp->sd_bsize];
unsigned int blocks =
- sdp->qcsize << (20 - sdp->sd_sb.sb_bsize_shift);
+ sdp->qcsize << (20 - sdp->sd_bsize_shift);
unsigned int x;
struct gfs2_meta_header mh;
@@ -362,9 +362,9 @@ static int add_qc(struct gfs2_sbd *sdp, struct jadd_opts *opts)
if ((error = set_flags(fd, JA_FL_CLEAR, FS_JOURNAL_DATA_FL)))
goto close_fd;
- memset(buf, 0, sdp->bsize);
+ memset(buf, 0, sdp->sd_bsize);
for (x=0; x<blocks; x++) {
- if (write(fd, buf, sdp->bsize) != sdp->bsize) {
+ if (write(fd, buf, sdp->sd_bsize) != sdp->sd_bsize) {
perror("add_qc write");
error = -1;
goto close_fd;
@@ -383,7 +383,7 @@ static int add_qc(struct gfs2_sbd *sdp, struct jadd_opts *opts)
gfs2_meta_header_out(&mh, buf);
for (x=0; x<blocks; x++) {
- if (write(fd, buf, sdp->bsize) != sdp->bsize) {
+ if (write(fd, buf, sdp->sd_bsize) != sdp->sd_bsize) {
perror("add_qc write");
error = 1;
goto close_fd;
@@ -413,7 +413,7 @@ static int gather_info(struct gfs2_sbd *sdp, struct jadd_opts *opts)
return -1;
}
- sdp->bsize = statbuf.f_bsize;
+ sdp->sd_bsize = statbuf.f_bsize;
sdp->blks_total = statbuf.f_blocks;
sdp->blks_alloced = sdp->blks_total - statbuf.f_bfree;
@@ -518,12 +518,12 @@ static int add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
{
int fd, error = 0;
char new_name[256], *buf;
- uint32_t x, blocks = sdp->jsize << (20 - sdp->sd_sb.sb_bsize_shift);
+ uint32_t x, blocks = sdp->jsize << (20 - sdp->sd_bsize_shift);
struct gfs2_log_header *lh;
uint64_t seq = RANDOM(blocks), addr = 0;
off_t off = 0;
- buf = calloc(1, sdp->bsize);
+ buf = calloc(1, sdp->sd_bsize);
if (buf == NULL)
return -1;
@@ -562,14 +562,14 @@ static int add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
lh->lh_blkno = cpu_to_be32(x);
hash = lgfs2_log_header_hash(buf);
lh->lh_hash = cpu_to_be32(hash);
- if (!(blk_addr = find_block_address(fd, off, sdp->bsize))) {
+ if (!(blk_addr = find_block_address(fd, off, sdp->sd_bsize))) {
error = -1;
goto close_fd;
}
lh->lh_addr = cpu_to_be64(blk_addr);
- hash = lgfs2_log_header_crc(buf, sdp->bsize);
+ hash = lgfs2_log_header_crc(buf, sdp->sd_bsize);
lh->lh_crc = cpu_to_be32(hash);
- if (write(fd, buf, sdp->bsize) != sdp->bsize) {
+ if (write(fd, buf, sdp->sd_bsize) != sdp->sd_bsize) {
perror("add_j write");
error = -1;
goto close_fd;
@@ -579,7 +579,7 @@ static int add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
if (++seq == blocks)
seq = 0;
- off += sdp->bsize;
+ off += sdp->sd_bsize;
}
error = fsync(fd);
@@ -610,8 +610,8 @@ static int check_fit(struct gfs2_sbd *sdp, struct jadd_opts *opts)
uint64_t blks_per_j, total_blks;
blks_per_j = 1 + 1 +
- lgfs2_space_for_data(sdp, sdp->bsize, sdp->qcsize << 20) +
- lgfs2_space_for_data(sdp, sdp->bsize, sdp->jsize << 20);
+ lgfs2_space_for_data(sdp, sdp->sd_bsize, sdp->qcsize << 20) +
+ lgfs2_space_for_data(sdp, sdp->sd_bsize, sdp->jsize << 20);
total_blks = opts->journals * blks_per_j;
if (total_blks > (sdp->blks_total - sdp->blks_alloced)) {
diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c
index 6374ebc7..bf9e0d6d 100644
--- a/gfs2/mkfs/main_mkfs.c
+++ b/gfs2/mkfs/main_mkfs.c
@@ -635,23 +635,23 @@ static int opts_check(struct mkfs_opts *opts)
return 0;
}
-static void print_results(struct gfs2_sb *sb, struct mkfs_opts *opts, uint64_t rgrps,
uint64_t fssize)
+static void print_results(struct gfs2_sbd *sb, struct mkfs_opts *opts)
{
char readable_uuid[36+1];
- uuid_unparse(sb->sb_uuid, readable_uuid);
+ uuid_unparse(sb->sd_uuid, readable_uuid);
printf("%-27s%s\n", _("Device:"), opts->dev.path);
- printf("%-27s%u\n", _("Block size:"), sb->sb_bsize);
+ printf("%-27s%u\n", _("Block size:"), sb->sd_bsize);
printf("%-27s%.2f %s (%"PRIu64" %s)\n", _("Device
size:"),
/* Translators: "GB" here means "gigabytes" */
(opts->dev.size / ((float)(1 << 30))), _("GB"),
- (opts->dev.size / sb->sb_bsize), _("blocks"));
+ (opts->dev.size / sb->sd_bsize), _("blocks"));
printf("%-27s%.2f %s (%"PRIu64" %s)\n", _("Filesystem
size:"),
- (fssize / ((float)(1 << 30)) * sb->sb_bsize), _("GB"), fssize,
_("blocks"));
+ (sb->fssize / ((float)(1 << 30)) * sb->sd_bsize), _("GB"),
sb->fssize, _("blocks"));
printf("%-27s%u\n", _("Journals:"), opts->journals);
printf("%-27s%uMB\n", _("Journal size:"), opts->jsize);
- printf("%-27s%"PRIu64"\n", _("Resource groups:"), rgrps);
+ printf("%-27s%"PRIu64"\n", _("Resource groups:"),
sb->rgrps);
printf("%-27s\"%s\"\n", _("Locking protocol:"),
opts->lockproto);
printf("%-27s\"%s\"\n", _("Lock table:"),
opts->locktable);
/* Translators: "UUID" = universally unique identifier. */
@@ -696,7 +696,7 @@ static int zero_gap(struct gfs2_sbd *sdp, uint64_t addr, size_t
blocks)
perror(_("Failed to zero blocks\n"));
return 1;
}
- zerobuf = calloc(1, sdp->bsize);
+ zerobuf = calloc(1, sdp->sd_bsize);
if (zerobuf == NULL) {
perror(_("Failed to zero blocks\n"));
free(iov);
@@ -704,10 +704,10 @@ static int zero_gap(struct gfs2_sbd *sdp, uint64_t addr, size_t
blocks)
}
for (i = 0; i < blocks; i++) {
iov[i].iov_base = zerobuf;
- iov[i].iov_len = sdp->bsize;
+ iov[i].iov_len = sdp->sd_bsize;
}
- wrote = pwritev(sdp->device_fd, iov, blocks, addr * sdp->bsize);
- if (wrote != blocks * sdp->bsize) {
+ wrote = pwritev(sdp->device_fd, iov, blocks, addr * sdp->sd_bsize);
+ if (wrote != blocks * sdp->sd_bsize) {
fprintf(stderr, _("Zeroing write failed at block %"PRIu64"\n"),
addr);
free(zerobuf);
free(iov);
@@ -725,17 +725,17 @@ static lgfs2_rgrps_t rgs_init(struct mkfs_opts *opts, struct
gfs2_sbd *sdp)
uint64_t al_off = 0;
if (opts->align && opts->got_sunit) {
- if ((opts->sunit % sdp->bsize) != 0) {
+ if ((opts->sunit % sdp->sd_bsize) != 0) {
fprintf(stderr, _("Stripe unit (%lu) must be a multiple of block size
(%u)\n"),
- opts->sunit, sdp->bsize);
+ opts->sunit, sdp->sd_bsize);
return NULL;
} else if ((opts->swidth % opts->sunit) != 0) {
fprintf(stderr, _("Stripe width (%lu) must be a multiple of stripe unit
(%lu)\n"),
opts->swidth, opts->sunit);
return NULL;
} else {
- al_base = opts->swidth / sdp->bsize;
- al_off = opts->sunit / sdp->bsize;
+ al_base = opts->swidth / sdp->sd_bsize;
+ al_off = opts->sunit / sdp->sd_bsize;
}
} else if (opts->align) {
if (opts->dev.optimal_io_size <= opts->dev.physical_sector_size ||
@@ -746,8 +746,8 @@ static lgfs2_rgrps_t rgs_init(struct mkfs_opts *opts, struct gfs2_sbd
*sdp)
rgrp alignment */
opts->align = 0;
} else {
- al_base = opts->dev.optimal_io_size / sdp->bsize;
- al_off = opts->dev.minimum_io_size / sdp->bsize;
+ al_base = opts->dev.optimal_io_size / sdp->sd_bsize;
+ al_off = opts->dev.minimum_io_size / sdp->sd_bsize;
}
}
@@ -770,7 +770,7 @@ static lgfs2_rgrps_t rgs_init(struct mkfs_opts *opts, struct gfs2_sbd
*sdp)
static int place_rgrp(struct gfs2_sbd *sdp, lgfs2_rgrp_t rg, int debug)
{
- uint64_t prev_end = (GFS2_SB_ADDR * GFS2_BASIC_BLOCK / sdp->bsize) + 1;
+ uint64_t prev_end = (GFS2_SB_ADDR * GFS2_BASIC_BLOCK / sdp->sd_bsize) + 1;
lgfs2_rgrp_t prev = lgfs2_rgrp_prev(rg);
struct gfs2_rindex ri;
uint64_t addr;
@@ -837,8 +837,8 @@ static int add_rgrp(lgfs2_rgrps_t rgs, uint64_t *addr, uint32_t len,
lgfs2_rgrp_
static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, struct mkfs_opts
*opts, uint64_t *rgaddr)
{
struct gfs2_progress_bar progress;
- uint64_t jfsize = lgfs2_space_for_data(sdp, sdp->bsize, opts->jsize << 20);
- uint32_t rgsize = lgfs2_rgsize_for_data(jfsize, sdp->bsize);
+ uint64_t jfsize = lgfs2_space_for_data(sdp, sdp->sd_bsize, opts->jsize <<
20);
+ uint32_t rgsize = lgfs2_rgsize_for_data(jfsize, sdp->sd_bsize);
unsigned j;
gfs2_progress_init(&progress, opts->journals, _("Adding journals: "),
opts->quiet);
@@ -912,7 +912,7 @@ static int place_journals(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs,
struct mkfs_o
static int place_rgrps(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, uint64_t *rgaddr, struct
mkfs_opts *opts)
{
struct gfs2_progress_bar progress;
- uint32_t rgblks = ((opts->rgsize << 20) / sdp->bsize);
+ uint32_t rgblks = ((opts->rgsize << 20) / sdp->sd_bsize);
uint32_t rgnum;
int result;
@@ -983,19 +983,24 @@ static int sbd_init(struct gfs2_sbd *sdp, struct mkfs_opts *opts,
unsigned bsize
sdp->jsize = opts->jsize;
sdp->md.journals = opts->journals;
sdp->device_fd = opts->dev.fd;
- sdp->bsize = sdp->sd_sb.sb_bsize = bsize;
+ sdp->sd_bsize = bsize;
+ sdp->sd_fs_format = opts->format;
+ sdp->sd_multihost_format = GFS2_FORMAT_MULTI;
+ sdp->sd_bsize = bsize;
+ sdp->sd_bsize_shift = ffs(bsize) - 1;
+ uuid_generate(sdp->sd_uuid);
if (compute_constants(sdp)) {
perror(_("Failed to compute file system constants"));
return -1;
}
- sdp->device.length = opts->dev.size / sdp->bsize;
+ sdp->device.length = opts->dev.size / sdp->sd_bsize;
if (opts->got_fssize) {
if (opts->fssize > sdp->device.length) {
fprintf(stderr, _("Specified size is bigger than the device."));
fprintf(stderr, "%s %.2f %s (%"PRIu64" %s)\n", _("Device
size:"),
opts->dev.size / ((float)(1 << 30)), _("GB"),
- opts->dev.size / sdp->bsize, _("blocks"));
+ opts->dev.size / sdp->sd_bsize, _("blocks"));
return -1;
}
sdp->device.length = opts->fssize;
@@ -1004,20 +1009,20 @@ static int sbd_init(struct gfs2_sbd *sdp, struct mkfs_opts *opts,
unsigned bsize
makes sense for the device size, or set a sensible default, if one
will fit. For user-provided journal sizes, limit it to half of the fs. */
if (!opts->got_jsize) {
- int default_jsize = default_journal_size(sdp->bsize, sdp->device.length /
opts->journals);
+ int default_jsize = default_journal_size(sdp->sd_bsize, sdp->device.length /
opts->journals);
unsigned jsize_mb;
if (default_jsize < 0) {
fprintf(stderr, _("gfs2 will not fit on this device.\n"));
return -1;
}
- jsize_mb = (default_jsize * sdp->bsize) >> 20;
+ jsize_mb = (default_jsize * sdp->sd_bsize) >> 20;
if (jsize_mb < GFS2_MIN_JSIZE)
opts->jsize = GFS2_MIN_JSIZE;
else
opts->jsize = jsize_mb;
- } else if ((((opts->jsize * opts->journals) << 20) / sdp->bsize) >
(sdp->device.length / 2)) {
- unsigned max_jsize = (sdp->device.length / 2 * sdp->bsize / opts->journals)
>> 20;
+ } else if ((((opts->jsize * opts->journals) << 20) / sdp->sd_bsize) >
(sdp->device.length / 2)) {
+ unsigned max_jsize = (sdp->device.length / 2 * sdp->sd_bsize / opts->journals)
>> 20;
fprintf(stderr, _("gfs2 will not fit on this device.\n"));
if (max_jsize >= GFS2_MIN_JSIZE)
@@ -1118,7 +1123,6 @@ static int open_dev(struct mkfs_dev *dev, int withprobe)
int main(int argc, char *argv[])
{
struct gfs2_sbd sbd;
- struct gfs2_sb sb;
struct mkfs_opts opts;
lgfs2_rgrps_t rgs;
uint64_t rgaddr;
@@ -1149,13 +1153,11 @@ int main(int argc, char *argv[])
if (S_ISREG(opts.dev.stat.st_mode)) {
opts.got_bsize = 1; /* Use default block size for regular files */
}
-
if (sbd_init(&sbd, &opts, bsize) != 0)
exit(-1);
- lgfs2_sb_init(&sb, bsize, opts.format);
if (opts.debug) {
printf(_("File system options:\n"));
- printf(" bsize = %u\n", sbd.bsize);
+ printf(" bsize = %u\n", sbd.sd_bsize);
printf(" qcsize = %u\n", sbd.qcsize);
printf(" jsize = %u\n", sbd.jsize);
printf(" journals = %u\n", sbd.md.journals);
@@ -1205,8 +1207,8 @@ int main(int argc, char *argv[])
fprintf(stderr, _("Error building '%s': %s\n"), "master",
strerror(errno));
exit(EXIT_FAILURE);
}
- sb.sb_master_dir.no_addr = sbd.master_dir->i_addr;
- sb.sb_master_dir.no_formal_ino = sbd.master_dir->i_formal_ino;
+ sbd.sd_meta_dir.no_addr = sbd.master_dir->i_addr;
+ sbd.sd_meta_dir.no_formal_ino = sbd.master_dir->i_formal_ino;
error = lgfs2_build_jindex(sbd.master_dir, mkfs_journals, opts.journals);
if (error) {
@@ -1249,13 +1251,13 @@ int main(int argc, char *argv[])
printf("%s", _("Done\n"));
build_root(&sbd);
- sb.sb_root_dir.no_addr = sbd.md.rooti->i_addr;
- sb.sb_root_dir.no_formal_ino = sbd.md.rooti->i_formal_ino;
+ sbd.sd_root_dir.no_addr = sbd.md.rooti->i_addr;
+ sbd.sd_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);
- sb.sb_lockproto[GFS2_LOCKNAME_LEN - 1] = '\0';
- sb.sb_locktable[GFS2_LOCKNAME_LEN - 1] = '\0';
+ strncpy(sbd.sd_lockproto, opts.lockproto, GFS2_LOCKNAME_LEN - 1);
+ strncpy(sbd.sd_locktable, opts.locktable, GFS2_LOCKNAME_LEN - 1);
+ sbd.sd_lockproto[GFS2_LOCKNAME_LEN - 1] = '\0';
+ sbd.sd_locktable[GFS2_LOCKNAME_LEN - 1] = '\0';
do_init_inum(&sbd);
do_init_statfs(&sbd);
@@ -1272,7 +1274,7 @@ int main(int argc, char *argv[])
fflush(stdout);
}
- error = lgfs2_sb_write(&sb, opts.dev.fd, sbd.bsize);
+ error = lgfs2_sb_write(&sbd, opts.dev.fd);
if (error) {
perror(_("Failed to write superblock\n"));
exit(EXIT_FAILURE);
@@ -1291,7 +1293,7 @@ int main(int argc, char *argv[])
if (!opts.quiet) {
printf("%s", _("Done\n"));
- print_results(&sb, &opts, sbd.rgrps, sbd.fssize);
+ print_results(&sbd, &opts);
}
return 0;
}
diff --git a/tests/nukerg.c b/tests/nukerg.c
index 3bca919c..b5ddeb0b 100644
--- a/tests/nukerg.c
+++ b/tests/nukerg.c
@@ -192,7 +192,7 @@ static int nuke_rgs(struct gfs2_sbd *sdp, lgfs2_rgrps_t rgs, unsigned
*rgnums, s
lgfs2_rindex_out(rg, &ri);
for (j = 0; j < count; j++) {
uint64_t addr = be64_to_cpu(ri.ri_addr);
- off_t off = addr * sdp->bsize;
+ off_t off = addr * sdp->sd_bsize;
ssize_t bytes;
if (i != rgnums[j] && rgnums[j] != ALL_RGS)
@@ -278,8 +278,7 @@ static lgfs2_rgrps_t read_rindex(struct gfs2_sbd *sdp)
static int fill_super_block(struct gfs2_sbd *sdp)
{
- sdp->sd_sb.sb_bsize = GFS2_BASIC_BLOCK;
- sdp->bsize = sdp->sd_sb.sb_bsize;
+ sdp->sd_bsize = GFS2_BASIC_BLOCK;
if (compute_constants(sdp) != 0) {
fprintf(stderr, "Failed to compute file system constants.\n");
@@ -289,7 +288,7 @@ static int fill_super_block(struct gfs2_sbd *sdp)
perror("Failed to read superblock\n");
return 1;
}
- sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_sb.sb_master_dir.no_addr);
+ sdp->master_dir = lgfs2_inode_read(sdp, sdp->sd_meta_dir.no_addr);
if (sdp->master_dir == NULL) {
fprintf(stderr, "Failed to read master directory inode.\n");
return 1;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.