This is an automated email from the git hooks/post-receive script.
andyp pushed a commit to branch master in repository gfs2-utils.
commit 414db3ab0db17074188cad16aa3944d3ea7ebc5e Author: Andrew Price anprice@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@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 61b37b75..f6dab286 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 91f2dcf6..09d25ae0 100644 --- a/gfs2/libgfs2/libgfs2.h +++ b/gfs2/libgfs2/libgfs2.h @@ -307,12 +307,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 */
@@ -331,7 +344,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;
@@ -736,8 +751,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); @@ -758,7 +772,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); @@ -774,8 +788,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 f44b76ee..f7d7553f 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 6168fcc9..b7f5f1de 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;
cluster-commits@lists.fedorahosted.org