gfs2-utils: master - gfs2_edit: print field names in right column
Bob Peterson
rpeterso at fedoraproject.org
Thu Oct 14 14:26:07 UTC 2010
Gitweb: http://git.fedorahosted.org/git/gfs2-utils.git?p=gfs2-utils.git;a=commitdiff;h=6f3660b367931cac7b52d4111e00bc6837fbd115
Commit: 6f3660b367931cac7b52d4111e00bc6837fbd115
Parent: 006099ae1f0d3074906d54b6d6086b1bca739bc5
Author: Bob Peterson <bob at ganesha.(none)>
AuthorDate: Mon Oct 4 18:37:31 2010 -0500
Committer: Bob Peterson <rpeterso at redhat.com>
CommitterDate: Thu Oct 14 09:10:11 2010 -0500
gfs2_edit: print field names in right column
This patch prints the field names in the righthand column as
you scroll around the screen in hex mode. Also, I moved the
location of the pointer number to print the same way.
rhbz#634623
---
gfs2/edit/hexedit.c | 654 ++++++++++++++++++++++++++++++++++++++++++---------
gfs2/edit/hexedit.h | 1 +
2 files changed, 546 insertions(+), 109 deletions(-)
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index 20634ac..f03f368 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -33,6 +33,14 @@ const char *allocdesc[2][5] = {
{"Free ", "Data ", "Unlnk", "Meta ", "Resrv"},
{"Free ", "Data ", "FreeM", "Meta ", "Resrv"},};
+struct gfs2_rgrp *lrgrp;
+struct gfs2_meta_header *lmh;
+struct gfs2_dinode *ldi;
+struct gfs2_leaf *lleaf;
+struct gfs2_log_header *llh;
+struct gfs2_log_descriptor *lld;
+int pgnum;
+
int display(int identify_only);
/* for assigning numeric fields: */
@@ -74,53 +82,486 @@ int display(int identify_only);
} \
} while(0)
-static int gfs2_sb_printval(struct gfs2_sb *sb, const char *strfield)
-{
- checkprint(strfield, sb, sb_fs_format);
- checkprint(strfield, sb, sb_multihost_format);
- checkprint(strfield, sb, __pad0);
- checkprint(strfield, sb, sb_bsize);
- checkprint(strfield, sb, sb_bsize_shift);
- checkprint(strfield, sb, __pad1);
- checkprint(strfield, sb, sb_master_dir.no_addr);
- checkprint(strfield, sb, __pad2.no_addr);
- checkprint(strfield, sb, sb_root_dir.no_addr);
- checkprints(strfield, sb, sb_lockproto);
- checkprints(strfield, sb, sb_locktable);
- checkprint(strfield, sb, __pad3.no_addr);
- checkprint(strfield, sb, __pad4.no_addr);
+/* -------------------------------------------------------------------------
+ * superblock
+ * ------------------------------------------------------------------------- */
+const int fieldsize_sb[] = {
+ sizeof(sb.sb_header.mh_magic),
+ sizeof(sb.sb_header.mh_type),
+ sizeof(sb.sb_header.__pad0),
+ sizeof(sb.sb_header.mh_format),
+ sizeof(sb.sb_header.__pad1),
+ sizeof(sb.sb_fs_format),
+ sizeof(sb.sb_multihost_format),
+ sizeof(sb.__pad0),
+ sizeof(sb.sb_bsize),
+ sizeof(sb.sb_bsize_shift),
+ sizeof(sb.__pad1),
+ sizeof(sb.sb_master_dir.no_formal_ino),
+ sizeof(sb.sb_master_dir.no_addr),
+ sizeof(sb.__pad2.no_formal_ino),
+ sizeof(sb.__pad2.no_addr),
+ sizeof(sb.sb_root_dir.no_formal_ino),
+ sizeof(sb.sb_root_dir.no_addr),
+ sizeof(sb.sb_lockproto),
+ sizeof(sb.sb_locktable),
+ sizeof(sb.__pad3.no_formal_ino),
+ sizeof(sb.__pad3.no_addr),
+ sizeof(sb.__pad4.no_formal_ino),
+ sizeof(sb.__pad4.no_addr),
+ sizeof(sb.sb_uuid),
+ -1
+};
+
+const char *fieldnames_sb[] = {
+ "mh_magic",
+ "mh_type",
+ "mh.__pad0",
+ "mh_format",
+ "mh.__pad1",
+ "sb_fs_format",
+ "sb_multihost_format",
+ "__pad0",
+ "sb_bsize",
+ "sb_bsize_shift",
+ "__pad1",
+ "master.no_formal_ino",
+ "master.no_addr",
+ "__pad2.no_formal_ino",
+ "__pad2.no_addr",
+ "root.no_formal_ino",
+ "root.no_addr",
+ "sb_lockproto",
+ "sb_locktable",
+ "__pad3.no_formal_ino",
+ "__pad3.no_addr",
+ "__pad4.no_formal_ino",
+ "__pad4.no_addr",
+ "sb_uuid",
+};
+
+/* This determines which field the cursor is located in */
+static int which_field_sb(int off)
+{
+ int i, tot;
+
+ tot = 0;
+ for (i = 0; fieldsize_sb[i] != -1; i++) {
+ tot += fieldsize_sb[i];
+ if (off < tot)
+ return i;
+ }
+ return -1;
+}
+
+static const char *which_fieldname_sb(int off)
+{
+ int w = which_field_sb(off);
+ if (w < 0)
+ return NULL;
+ return fieldnames_sb[w];
+}
+
+/* -------------------------------------------------------------------------
+ * rgrp
+ * ------------------------------------------------------------------------- */
+const int fieldsize_rgrp[] = {
+ sizeof(lrgrp->rg_header.mh_magic),
+ sizeof(lrgrp->rg_header.mh_type),
+ sizeof(lrgrp->rg_header.__pad0),
+ sizeof(lrgrp->rg_header.mh_format),
+ sizeof(lrgrp->rg_header.__pad1),
+ sizeof(lrgrp->rg_flags),
+ sizeof(lrgrp->rg_free),
+ sizeof(lrgrp->rg_dinodes),
+ sizeof(lrgrp->__pad),
+ sizeof(lrgrp->rg_igeneration),
+ sizeof(lrgrp->rg_reserved),
+ -1
+};
+
+const char *fieldnames_rgrp[] = {
+ "mh_magic",
+ "mh_type",
+ "mh.__pad0",
+ "mh_format",
+ "mh.__pad1",
+ "rg_flags",
+ "rg_free",
+ "rg_dinodes",
+ "__pad",
+ "rg_igeneration",
+ "rg_reserved",
+};
+
+static int which_field_rgrp(int off)
+{
+ int i, tot;
+
+ tot = 0;
+ for (i = 0; fieldsize_rgrp[i] != -1; i++) {
+ tot += fieldsize_rgrp[i];
+ if (off < tot)
+ return i;
+ }
+ return -1;
+}
+
+static const char *which_fieldname_rgrp(int off)
+{
+ int w = which_field_rgrp(off);
+ if (w < 0)
+ return NULL;
+ return fieldnames_rgrp[w];
+}
+
+/* -------------------------------------------------------------------------
+ * metaheader
+ * ------------------------------------------------------------------------- */
+const int fieldsize_mh[] = {
+ sizeof(lmh->mh_magic),
+ sizeof(lmh->mh_type),
+ sizeof(lmh->__pad0),
+ sizeof(lmh->mh_format),
+ sizeof(lmh->__pad1),
+ -1
+};
+
+const char *fieldnames_mh[] = {
+ "mh_magic",
+ "mh_type",
+ "mh.__pad0",
+ "mh_format",
+ "mh.__pad1",
+};
+
+static int which_field_mh(int off)
+{
+ int i, tot;
+
+ tot = 0;
+ for (i = 0; fieldsize_mh[i] != -1; i++) {
+ tot += fieldsize_mh[i];
+ if (off < tot)
+ return i;
+ }
+ return -1;
+}
+
+static const char *which_fieldname_mh(int off)
+{
+ int w = which_field_mh(off);
+ if (w < 0)
+ return NULL;
+ return fieldnames_mh[w];
+}
+
+/* -------------------------------------------------------------------------
+ * dinode
+ * ------------------------------------------------------------------------- */
+const int fieldsize_di[] = {
+ sizeof(ldi->di_header.mh_magic),
+ sizeof(ldi->di_header.mh_type),
+ sizeof(ldi->di_header.__pad0),
+ sizeof(ldi->di_header.mh_format),
+ sizeof(ldi->di_header.__pad1),
+ sizeof(ldi->di_num.no_formal_ino),
+ sizeof(ldi->di_num.no_addr),
+ sizeof(ldi->di_mode),
+ sizeof(ldi->di_uid),
+ sizeof(ldi->di_gid),
+ sizeof(ldi->di_nlink),
+ sizeof(ldi->di_size),
+ sizeof(ldi->di_blocks),
+ sizeof(ldi->di_atime),
+ sizeof(ldi->di_mtime),
+ sizeof(ldi->di_ctime),
+ sizeof(ldi->di_major),
+ sizeof(ldi->di_minor),
+ sizeof(ldi->di_goal_meta),
+ sizeof(ldi->di_goal_data),
+ sizeof(ldi->di_generation),
+ sizeof(ldi->di_flags),
+ sizeof(ldi->di_payload_format),
+ sizeof(ldi->__pad1),
+ sizeof(ldi->di_height),
+ sizeof(ldi->__pad2),
+ sizeof(ldi->__pad3),
+ sizeof(ldi->di_depth),
+ sizeof(ldi->di_entries),
+ sizeof(ldi->__pad4.no_formal_ino),
+ sizeof(ldi->__pad4.no_addr),
+ sizeof(ldi->di_eattr),
+ sizeof(ldi->di_atime_nsec),
+ sizeof(ldi->di_mtime_nsec),
+ sizeof(ldi->di_ctime_nsec),
+ sizeof(ldi->di_reserved),
+ -1
+};
+
+const char *fieldnames_di[] = {
+ "mh_magic",
+ "mh_type",
+ "mh.__pad0",
+ "mh_format",
+ "mh.__pad1",
+ "no_formal_ino",
+ "no_addr",
+ "di_mode",
+ "di_uid",
+ "di_gid",
+ "di_nlink",
+ "di_size",
+ "di_blocks",
+ "di_atime",
+ "di_mtime",
+ "di_ctime",
+ "di_major",
+ "di_minor",
+ "di_goal_meta",
+ "di_goal_data",
+ "di_generation",
+ "di_flags",
+ "di_payload_format",
+ "__pad1",
+ "di_height",
+ "__pad2",
+ "__pad3",
+ "di_depth",
+ "di_entries",
+ "__pad4.no_formal_ino",
+ "__pad4.no_addr",
+ "di_eattr",
+ "di_atime_nsec",
+ "di_mtime_nsec",
+ "di_ctime_nsec",
+ "di_reserved",
+};
+
+static int which_field_di(int off)
+{
+ int i, tot;
+
+ tot = 0;
+ for (i = 0; fieldsize_di[i] != -1; i++) {
+ tot += fieldsize_di[i];
+ if (off < tot)
+ return i;
+ }
+ return -1;
+}
+
+static const char *which_fieldname_di(int off)
+{
+ int w = which_field_di(off);
+ if (w < 0)
+ return NULL;
+ return fieldnames_di[w];
+}
+
+/* -------------------------------------------------------------------------
+ * directory leaf
+ * ------------------------------------------------------------------------- */
+const int fieldsize_lf[] = {
+ sizeof(lleaf->lf_header.mh_magic),
+ sizeof(lleaf->lf_header.mh_type),
+ sizeof(lleaf->lf_header.__pad0),
+ sizeof(lleaf->lf_header.mh_format),
+ sizeof(lleaf->lf_header.__pad1),
+ sizeof(lleaf->lf_depth),
+ sizeof(lleaf->lf_entries),
+ sizeof(lleaf->lf_dirent_format),
+ sizeof(lleaf->lf_next),
+ sizeof(lleaf->lf_reserved),
+ -1
+};
+
+const char *fieldnames_lf[] = {
+ "mh_magic",
+ "mh_type",
+ "mh.__pad0",
+ "mh_format",
+ "mh.__pad1",
+ "lf_depth",
+ "lf_entries",
+ "lf_dirent_format",
+ "lf_next",
+ "lf_reserved",
+};
+
+static int which_field_lf(int off)
+{
+ int i, tot;
+
+ tot = 0;
+ for (i = 0; fieldsize_lf[i] != -1; i++) {
+ tot += fieldsize_lf[i];
+ if (off < tot)
+ return i;
+ }
+ return -1;
+}
+
+static const char *which_fieldname_lf(int off)
+{
+ int w = which_field_lf(off);
+ if (w < 0)
+ return NULL;
+ return fieldnames_lf[w];
+}
+
+/* -------------------------------------------------------------------------
+ * log header
+ * ------------------------------------------------------------------------- */
+const int fieldsize_lh[] = {
+ sizeof(llh->lh_header.mh_magic),
+ sizeof(llh->lh_header.mh_type),
+ sizeof(llh->lh_header.__pad0),
+ sizeof(llh->lh_header.mh_format),
+ sizeof(llh->lh_header.__pad1),
+ sizeof(llh->lh_sequence),
+ sizeof(llh->lh_flags),
+ sizeof(llh->lh_tail),
+ sizeof(llh->lh_blkno),
+ sizeof(llh->lh_hash),
+ -1
+};
+
+const char *fieldnames_lh[] = {
+ "mh_magic",
+ "mh_type",
+ "mh.__pad0",
+ "mh_format",
+ "mh.__pad1",
+ "lh_sequence",
+ "lh_flags",
+ "lh_tail",
+ "lh_blkno",
+ "lh_hash",
+};
+
+static int which_field_lh(int off)
+{
+ int i, tot;
+
+ tot = 0;
+ for (i = 0; fieldsize_lh[i] != -1; i++) {
+ tot += fieldsize_lh[i];
+ if (off < tot)
+ return i;
+ }
+ return -1;
+}
+
+static const char *which_fieldname_lh(int off)
+{
+ int w = which_field_lh(off);
+ if (w < 0)
+ return NULL;
+ return fieldnames_lh[w];
+}
+
+/* -------------------------------------------------------------------------
+ * log descriptor
+ * ------------------------------------------------------------------------- */
+const int fieldsize_ld[] = {
+ sizeof(lld->ld_header.mh_magic),
+ sizeof(lld->ld_header.mh_type),
+ sizeof(lld->ld_header.__pad0),
+ sizeof(lld->ld_header.mh_format),
+ sizeof(lld->ld_header.__pad1),
+ sizeof(lld->ld_type),
+ sizeof(lld->ld_length),
+ sizeof(lld->ld_data1),
+ sizeof(lld->ld_data2),
+ sizeof(lld->ld_reserved),
+ -1
+};
+
+const char *fieldnames_ld[] = {
+ "mh_magic",
+ "mh_type",
+ "mh.__pad0",
+ "mh_format",
+ "mh.__pad1",
+ "ld_type",
+ "ld_length",
+ "ld_data1",
+ "ld_data2",
+ "ld_reserved",
+};
+
+static int which_field_ld(int off)
+{
+ int i, tot;
+
+ tot = 0;
+ for (i = 0; fieldsize_ld[i] != -1; i++) {
+ tot += fieldsize_ld[i];
+ if (off < tot)
+ return i;
+ }
+ return -1;
+}
+
+static const char *which_fieldname_ld(int off)
+{
+ int w = which_field_ld(off);
+ if (w < 0)
+ return NULL;
+ return fieldnames_ld[w];
+}
+
+/* -------------------------------------------------------------------------
+ * field-related functions:
+ * ------------------------------------------------------------------------- */
+static int gfs2_sb_printval(struct gfs2_sb *lsb, const char *strfield)
+{
+ checkprint(strfield, lsb, sb_fs_format);
+ checkprint(strfield, lsb, sb_multihost_format);
+ checkprint(strfield, lsb, __pad0);
+ checkprint(strfield, lsb, sb_bsize);
+ checkprint(strfield, lsb, sb_bsize_shift);
+ checkprint(strfield, lsb, __pad1);
+ checkprint(strfield, lsb, sb_master_dir.no_addr);
+ checkprint(strfield, lsb, __pad2.no_addr);
+ checkprint(strfield, lsb, sb_root_dir.no_addr);
+ checkprints(strfield, lsb, sb_lockproto);
+ checkprints(strfield, lsb, sb_locktable);
+ checkprint(strfield, lsb, __pad3.no_addr);
+ checkprint(strfield, lsb, __pad4.no_addr);
if (strcmp(strfield, "sb_uuid") == 0) {
- printf("%s\n", str_uuid(sb->sb_uuid));
+ printf("%s\n", str_uuid(lsb->sb_uuid));
return 0;
}
return -1;
}
-static int gfs2_sb_assignval(struct gfs2_sb *sb, const char *strfield,
+static int gfs2_sb_assignval(struct gfs2_sb *lsb, const char *strfield,
uint64_t value)
{
- checkassign(strfield, sb, sb_fs_format, value);
- checkassign(strfield, sb, sb_multihost_format, value);
- checkassign(strfield, sb, __pad0, value);
- checkassign(strfield, sb, sb_bsize, value);
- checkassign(strfield, sb, sb_bsize_shift, value);
- checkassign(strfield, sb, __pad1, value);
- checkassign(strfield, sb, sb_master_dir.no_addr, value);
- checkassign(strfield, sb, __pad2.no_addr, value);
- checkassign(strfield, sb, sb_root_dir.no_addr, value);
- checkassign(strfield, sb, __pad3.no_addr, value);
- checkassign(strfield, sb, __pad4.no_addr, value);
+ checkassign(strfield, lsb, sb_fs_format, value);
+ checkassign(strfield, lsb, sb_multihost_format, value);
+ checkassign(strfield, lsb, __pad0, value);
+ checkassign(strfield, lsb, sb_bsize, value);
+ checkassign(strfield, lsb, sb_bsize_shift, value);
+ checkassign(strfield, lsb, __pad1, value);
+ checkassign(strfield, lsb, sb_master_dir.no_addr, value);
+ checkassign(strfield, lsb, __pad2.no_addr, value);
+ checkassign(strfield, lsb, sb_root_dir.no_addr, value);
+ checkassign(strfield, lsb, __pad3.no_addr, value);
+ checkassign(strfield, lsb, __pad4.no_addr, value);
return -1;
}
-static int gfs2_sb_assigns(struct gfs2_sb *sb, const char *strfield,
+static int gfs2_sb_assigns(struct gfs2_sb *lsb, const char *strfield,
const char *val)
{
- checkassigns(strfield, sb, sb_lockproto, val);
- checkassigns(strfield, sb, sb_locktable, val);
- checkassigns(strfield, sb, sb_uuid, val);
+ checkassigns(strfield, lsb, sb_lockproto, val);
+ checkassigns(strfield, lsb, sb_locktable, val);
+ checkassigns(strfield, lsb, sb_uuid, val);
return -1;
}
@@ -713,7 +1154,7 @@ int display_block_type(int from_restore)
if (from_restore)
return ret_type;
if (termlines && dmode == HEX_MODE) {
- int type, pgnum;
+ int type;
struct rgrp_list *rgd;
rgd = gfs2_blk2rgrpd(&sbd, block);
@@ -735,75 +1176,6 @@ int display_block_type(int from_restore)
sbd.bsize / screen_chunk_size + 1 : sbd.bsize /
screen_chunk_size, allocdesc[gfs1][type]);
/*eol(9);*/
- if ((*(bh->b_data + 7) == GFS2_METATYPE_IN) ||
- (*(bh->b_data + 7) == GFS2_METATYPE_DI &&
- (*(bh->b_data + 0x8b) || *(bh->b_data + 0x8a)))) {
- int ptroffset = edit_row[dmode] * 16 + edit_col[dmode];
-
- if (ptroffset >= struct_len || pgnum) {
- int pnum;
-
- pnum = pgnum * screen_chunk_size;
- pnum += (ptroffset - struct_len);
- pnum /= sizeof(uint64_t);
-
- print_gfs2(" pointer 0x%x", pnum);
- }
- }
- else if ((*(bh->b_data + 7) == GFS2_METATYPE_RG)) {
- int ptroffset = edit_row[dmode] * 16 + edit_col[dmode];
-
- if (ptroffset >= struct_len || pgnum) {
- int blknum, b, btype;
-
- blknum = pgnum * screen_chunk_size;
- blknum += (ptroffset - struct_len);
- blknum *= 4;
- blknum += rgd->ri.ri_data0;
-
- print_gfs2(" blk ");
- for (b = blknum; b < blknum + 4; b++) {
- btype = gfs2_get_bitmap(&sbd, b, rgd);
- print_gfs2("0x%x-%s ", b,
- allocdesc[gfs1][btype]);
- }
- }
- }
- else if ((*(bh->b_data + 7) == GFS2_METATYPE_RB)) {
- int ptroffset = edit_row[dmode] * 16 + edit_col[dmode];
-
- if (ptroffset >= struct_len || pgnum) {
- int blknum, b, btype, rb_number;
-
- rb_number = block - rgd->ri.ri_addr;
- blknum = 0;
- /* count the number of bytes representing
- blocks prior to the displayed screen. */
- for (b = 0; b < rb_number; b++) {
- struct_len = (b ?
- sizeof(struct gfs2_meta_header) :
- sizeof(struct gfs2_rgrp));
- blknum += (sbd.bsize - struct_len);
- }
- struct_len = sizeof(struct gfs2_meta_header);
- /* add the number of bytes on this screen */
- blknum += (ptroffset - struct_len);
- /* factor in the page number */
- blknum += pgnum * screen_chunk_size;
- /* convert bytes to blocks */
- blknum *= GFS2_NBBY;
- /* add the starting offset for this rgrp */
- blknum += rgd->ri.ri_data0;
- print_gfs2(" blk ");
- for (b = blknum; b < blknum + 4; b++) {
- btype = gfs2_get_bitmap(&sbd, b, rgd);
- print_gfs2("0x%x-%s ", b,
- allocdesc[gfs1][btype]);
- }
- }
- }
- if (rgd)
- gfs2_rgrp_relse(rgd);
}
if (block == sbd.sd_sb.sb_root_dir.no_addr)
print_gfs2("--------------- Root directory ------------------");
@@ -856,6 +1228,7 @@ static int hexdump(uint64_t startaddr, int len)
int i;
uint64_t l;
const char *lpBuffer = bh->b_data;
+ int print_field, cursor_line;
strcpy(edit_fmt,"%02x");
pointer = (unsigned char *)lpBuffer + offset;
@@ -884,6 +1257,8 @@ static int hexdump(uint64_t startaddr, int len)
else
COLORS_SPECIAL; /* beyond end of the struct */
}
+ print_field = -1;
+ cursor_line = 0;
for (i = 0; i < 16; i++) { /* first print it in hex */
/* Figure out if we have a null pointer--for colors */
if (((gfs2_struct_type == GFS2_METATYPE_IN) ||
@@ -928,6 +1303,8 @@ static int hexdump(uint64_t startaddr, int len)
COLORS_HIGHLIGHT; /* in the structure */
memset(estring,0,3);
sprintf(estring,"%02x",*pointer);
+ cursor_line = 1;
+ print_field = (char *)pointer - bh->b_data;
}
print_gfs2("%02x",*pointer);
if (termlines && line == edit_row[dmode] + 3 &&
@@ -948,6 +1325,65 @@ static int hexdump(uint64_t startaddr, int len)
ptr2++;
}
print_gfs2("] ");
+ if (print_field >= 0) {
+ switch (get_block_type(bh)) {
+ case GFS2_METATYPE_SB: /* 1 */
+ print_gfs2(which_fieldname_sb(print_field));
+ break;
+ case GFS2_METATYPE_RG: /* 2 */
+ print_gfs2(which_fieldname_rgrp(print_field));
+ break;
+ case GFS2_METATYPE_RB: /* 3 */
+ print_gfs2(which_fieldname_mh(print_field));
+ break;
+ case GFS2_METATYPE_DI: /* 4 */
+ print_gfs2(which_fieldname_di(print_field));
+ break;
+ case GFS2_METATYPE_IN: /* 5 */
+ print_gfs2(which_fieldname_mh(print_field));
+ break;
+ case GFS2_METATYPE_LF: /* 6 */
+ print_gfs2(which_fieldname_lf(print_field));
+ break;
+ case GFS2_METATYPE_JD:
+ print_gfs2(which_fieldname_mh(print_field));
+ break;
+ case GFS2_METATYPE_LH:
+ print_gfs2(which_fieldname_lh(print_field));
+ break;
+ case GFS2_METATYPE_LD:
+ print_gfs2(which_fieldname_ld(print_field));
+ break;
+ case GFS2_METATYPE_EA:
+ break;
+ case GFS2_METATYPE_ED:
+ break;
+ case GFS2_METATYPE_LB:
+ break;
+ case GFS2_METATYPE_QC:
+ break;
+ default:
+ break;
+ }
+ }
+ if (cursor_line) {
+ if (((*(bh->b_data + 7) == GFS2_METATYPE_IN) ||
+ (*(bh->b_data + 7) == GFS2_METATYPE_DI &&
+ (*(bh->b_data + 0x8b) || *(bh->b_data + 0x8a))))) {
+ int ptroffset = edit_row[dmode] * 16 +
+ edit_col[dmode];
+
+ if (ptroffset >= struct_len || pgnum) {
+ int pnum;
+
+ pnum = pgnum * screen_chunk_size;
+ pnum += (ptroffset - struct_len);
+ pnum /= sizeof(uint64_t);
+
+ print_gfs2("pointer 0x%x", pnum);
+ }
+ }
+ }
if (line - 3 > last_entry_onscreen[dmode])
last_entry_onscreen[dmode] = line - 3;
eol(0);
@@ -2110,7 +2546,7 @@ static void process_field(const char *field, const char *nstr)
int type;
struct gfs2_rgrp rg;
struct gfs2_leaf leaf;
- struct gfs2_sb sb;
+ struct gfs2_sb lsb;
struct gfs2_log_header lh;
struct gfs2_log_descriptor ld;
struct gfs2_quota_change qc;
@@ -2133,17 +2569,17 @@ static void process_field(const char *field, const char *nstr)
type = get_block_type(rbh);
switch (type) {
case GFS2_METATYPE_SB:
- gfs2_sb_in(&sb, rbh);
+ gfs2_sb_in(&lsb, rbh);
if (setval) {
if (setstring)
- gfs2_sb_assigns(&sb, field, nstr);
+ gfs2_sb_assigns(&lsb, field, nstr);
else
- gfs2_sb_assignval(&sb, field, newval);
- gfs2_sb_out(&sb, rbh);
+ gfs2_sb_assignval(&lsb, field, newval);
+ gfs2_sb_out(&lsb, rbh);
if (!termlines)
- gfs2_sb_printval(&sb, field);
+ gfs2_sb_printval(&lsb, field);
} else {
- if (!termlines && gfs2_sb_printval(&sb, field))
+ if (!termlines && gfs2_sb_printval(&lsb, field))
printf("Field '%s' not found.\n", field);
}
break;
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index ee34c7d..a7a3109 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -47,6 +47,7 @@ enum dsp_mode { HEX_MODE = 0, GFS2_MODE = 1, EXTENDED_MODE = 2, INIT_MODE = 3 };
} while (FALSE);
#define RGLIST_DUMMY_BLOCK -2
+extern struct gfs2_sb sb;
extern uint64_t block;
extern int blockhist;
extern int edit_mode;
More information about the cluster-commits
mailing list