[Cluster-devel] [PATCH] libgfs2: Import gfs2_ondisk.h
Andrew Price
anprice at redhat.com
Tue Apr 9 09:41:53 UTC 2019
Give gfs2-utils its own copy of gfs2_ondisk.h which uses userspace
types. This allows us to always support the latest ondisk structures and
obsoletes a lot of #ifdef GFS2_HAS_<FEATURE> blocks and configure.ac
checks.
gfs2_ondisk.h was changed simply by search-and-replace of the kernel int
types with the uintN_t, i.e.:
:%s/__u\(8\|16\|32\|64\)/uint\1_t/g
:%s/__be\(64\|32\|16\|8\)/uint\1_t/g
and the linux/types.h include replaced with stdint.h
A bunch of format strings were updated to use PRI* from inttypes.h to
fix issues where the kernel types were typedef'd to long long and the
userspace types are just long, for instance, despite being the same
width on x86_64.
Signed-off-by: Andrew Price <anprice at redhat.com>
---
configure.ac | 16 -
gfs2/convert/gfs2_convert.c | 3 +-
gfs2/edit/extended.c | 41 +--
gfs2/edit/gfs2hex.c | 19 +-
gfs2/edit/hexedit.c | 3 +-
gfs2/edit/hexedit.h | 2 +-
gfs2/edit/journal.c | 13 +-
gfs2/edit/savemeta.c | 3 +-
gfs2/fsck/fs_recovery.c | 30 +-
gfs2/fsck/initialize.c | 50 ++-
gfs2/fsck/lost_n_found.c | 12 +-
gfs2/fsck/pass1.c | 2 +-
gfs2/fsck/pass2.c | 2 +-
gfs2/fsck/rgrepair.c | 29 +-
gfs2/include/gfs2_ondisk.h | 535 +++++++++++++++++++++++++++++++++
gfs2/libgfs2/buf.c | 1 -
gfs2/libgfs2/device_geometry.c | 1 -
gfs2/libgfs2/fs_geometry.c | 1 -
gfs2/libgfs2/fs_ops.c | 7 -
gfs2/libgfs2/gfs1.c | 3 +-
gfs2/libgfs2/lang.c | 11 +-
gfs2/libgfs2/libgfs2.h | 103 +++----
gfs2/libgfs2/meta.c | 31 +-
gfs2/libgfs2/ondisk.c | 261 ++++++----------
gfs2/libgfs2/recovery.c | 2 -
gfs2/libgfs2/rgrp.c | 8 -
gfs2/libgfs2/structures.c | 22 +-
gfs2/mkfs/gfs2_mkfs.h | 2 +-
gfs2/mkfs/main_grow.c | 1 -
gfs2/mkfs/main_jadd.c | 7 -
gfs2/mkfs/main_mkfs.c | 14 +-
gfs2/tune/super.c | 18 +-
32 files changed, 770 insertions(+), 483 deletions(-)
create mode 100644 gfs2/include/gfs2_ondisk.h
diff --git a/configure.ac b/configure.ac
index 0c1b0192..51e0cc0a 100644
--- a/configure.ac
+++ b/configure.ac
@@ -126,23 +126,7 @@ AC_SUBST([udevdir], [$with_udevdir])
# Checks for header files.
AC_CHECK_HEADERS([fcntl.h libintl.h limits.h locale.h mntent.h stddef.h sys/file.h sys/ioctl.h sys/mount.h sys/time.h sys/vfs.h syslog.h termios.h])
AC_CHECK_HEADER([linux/fs.h], [], [AC_MSG_ERROR([Unable to find linux/fs.h])])
-AC_CHECK_HEADER([linux/types.h], [], [AC_MSG_ERROR([Unable to find linux/types.h])])
AC_CHECK_HEADER([linux/limits.h], [], [AC_MSG_ERROR([Unable to find linux/limits.h])])
-AC_CHECK_HEADER([linux/gfs2_ondisk.h], [], [AC_MSG_ERROR([Unable to find linux/gfs2_ondisk.h])])
-AC_CHECK_MEMBER([struct gfs2_sb.sb_uuid], [sb_has_uuid=yes], [sb_has_uuid=no],
- [[#include <linux/gfs2_ondisk.h>]])
-AC_CHECK_MEMBER([struct gfs2_leaf.lf_inode],[AC_DEFINE([GFS2_HAS_LEAF_HINTS],[],[Leaf block hints])],
- [], [[#include <linux/gfs2_ondisk.h>]])
-AC_CHECK_MEMBER([struct gfs2_dirent.de_rahead],[AC_DEFINE([GFS2_HAS_DE_RAHEAD],[],[Dirent readahead field])],
- [], [[#include <linux/gfs2_ondisk.h>]])
-AC_CHECK_MEMBER([struct gfs2_dirent.de_cookie],[AC_DEFINE([GFS2_HAS_DE_COOKIE],[],[Dirent cookie field])],
- [], [[#include <linux/gfs2_ondisk.h>]])
-AC_CHECK_MEMBER([struct gfs2_rgrp.rg_skip],[AC_DEFINE([GFS2_HAS_RG_SKIP],[],[Next resource group pointer])],
- [], [[#include <linux/gfs2_ondisk.h>]])
-AC_CHECK_MEMBER([struct gfs2_rgrp.rg_data0],[AC_DEFINE([GFS2_HAS_RG_RI_FIELDS],[],[Resource group fields duplicated from the rindex])],
- [], [[#include <linux/gfs2_ondisk.h>]])
-AC_CHECK_MEMBER([struct gfs2_log_header.lh_crc],[AC_DEFINE([GFS2_HAS_LH_V2],[],[v2 log header format])],
- [], [[#include <linux/gfs2_ondisk.h>]])
# libuuid is only required if struct gfs2_sb.sb_uuid exists
if test "$sb_has_uuid" = "yes" -a "$have_uuid" = "no"; then
diff --git a/gfs2/convert/gfs2_convert.c b/gfs2/convert/gfs2_convert.c
index 9cf97b65..558a935d 100644
--- a/gfs2/convert/gfs2_convert.c
+++ b/gfs2/convert/gfs2_convert.c
@@ -28,8 +28,7 @@
#include <locale.h>
#define _(String) gettext(String)
-#include <linux/types.h>
-#include <linux/gfs2_ondisk.h>
+#include <gfs2_ondisk.h>
#include <logging.h>
#include "osi_list.h"
#include "copyright.cf"
diff --git a/gfs2/edit/extended.c b/gfs2/edit/extended.c
index d24d7550..c46e522e 100644
--- a/gfs2/edit/extended.c
+++ b/gfs2/edit/extended.c
@@ -6,7 +6,6 @@
#include <string.h>
#include <inttypes.h>
#include <sys/types.h>
-#include <linux/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
@@ -19,7 +18,7 @@
#include <sys/mount.h>
#include <dirent.h>
-#include <linux/gfs2_ondisk.h>
+#include <gfs2_ondisk.h>
#include "copyright.cf"
#include "hexedit.h"
@@ -233,7 +232,7 @@ static int display_indirect(struct iinfo *ind, int indblocks, int level,
return 0;
}
-static void print_inode_type(__be16 de_type)
+static void print_inode_type(uint16_t de_type)
{
if (sbd.gfs1) {
switch(de_type) {
@@ -298,15 +297,6 @@ static void print_inode_type(__be16 de_type)
}
}
-#ifdef GFS2_HAS_LEAF_HINTS
-#define LEAF_HINT_FMTS "lf_inode: 0x%llx, lf_dist: %u, " \
- "lf_nsec: %u, lf_sec: %llu, "
-#define LEAF_HINT_FIELDS(lp) lp->lf_inode, lp->lf_dist, lp->lf_nsec, lp->lf_sec,
-#else
-#define LEAF_HINT_FMTS
-#define LEAF_HINT_FIELDS(lp)
-#endif
-
static int display_leaf(struct iinfo *ind)
{
struct gfs2_leaf *leaf = &ind->ii[0].lf;
@@ -318,10 +308,11 @@ static int display_leaf(struct iinfo *ind)
print_gfs2("The superblock has 2 directories");
else
print_gfs2("Directory block: lf_depth:%d, lf_entries:%d, "
- LEAF_HINT_FMTS
- "fmt:%d next=0x%llx (%d dirents).",
+ "lf_inode: 0x%"PRIx64", lf_dist: %u, lf_nsec: %u, "
+ "lf_sec: %"PRIu64", fmt:%d next=0x%"PRIx64" (%d dirents).",
leaf->lf_depth, leaf->lf_entries,
- LEAF_HINT_FIELDS(leaf)
+ leaf->lf_inode, leaf->lf_dist,
+ leaf->lf_nsec, leaf->lf_sec,
leaf->lf_dirent_format,
leaf->lf_next,
ind->ii[0].dirents);
@@ -344,18 +335,14 @@ static int display_leaf(struct iinfo *ind)
strcpy(edit_fmt, "%llx");
}
}
- print_gfs2("%d/%d [%08x] %lld/%"PRId64" (0x%llx/0x%"PRIx64") +%u: ",
+ print_gfs2("%d/%d [%08x] %"PRId64"/%"PRId64" (0x%"PRIx64"/0x%"PRIx64") +%"PRIu16": ",
total_dirents, d + 1,
ind->ii[0].dirent[d].dirent.de_hash,
ind->ii[0].dirent[d].dirent.de_inum.no_formal_ino,
ind->ii[0].dirent[d].block,
ind->ii[0].dirent[d].dirent.de_inum.no_formal_ino,
ind->ii[0].dirent[d].block,
-#ifdef GFS2_HAS_DE_RAHEAD
- (unsigned int)ind->ii[0].dirent[d].dirent.de_rahead
-#else
- 0
-#endif
+ ind->ii[0].dirent[d].dirent.de_rahead
);
}
print_inode_type(ind->ii[0].dirent[d].dirent.de_type);
@@ -453,7 +440,7 @@ static int print_gfs_jindex(struct gfs2_inode *dij)
char jbuf[sizeof(struct gfs_jindex)];
start_line = line;
- print_gfs2("Journal index entries found: %lld.",
+ print_gfs2("Journal index entries found: %"PRIu64".",
dij->i_di.di_size / sizeof(struct gfs_jindex));
eol(0);
lines_per_row[dmode] = 4;
@@ -495,7 +482,7 @@ static int print_gfs2_jindex(void)
if (strncmp(indirect->ii[0].dirent[d].filename, "journal", 7))
continue;
ip = lgfs2_inode_read(&sbd, indirect->ii[0].dirent[d].block);
- print_gfs2("%s: 0x%-5"PRIx64" %lldMB ",
+ print_gfs2("%s: 0x%-5"PRIx64" %"PRIu64"MB ",
indirect->ii[0].dirent[d].filename,
indirect->ii[0].dirent[d].block,
ip->i_di.di_size / 1048576);
@@ -522,7 +509,7 @@ static int parse_rindex(struct gfs2_inode *dip, int print_rindex)
char highlighted_addr[32];
start_line = line;
- print_gfs2("RG index entries found: %lld.", dip->i_di.di_size /
+ print_gfs2("RG index entries found: %"PRIu64".", dip->i_di.di_size /
sizeof(struct gfs2_rindex));
eol(0);
lines_per_row[dmode] = 6;
@@ -548,7 +535,7 @@ static int parse_rindex(struct gfs2_inode *dip, int print_rindex)
}
print_gfs2("RG #%d", print_entry_ndx);
if (!print_rindex)
- print_gfs2(" located at: %llu (0x%llx)",
+ print_gfs2(" located at: %"PRIu64" (0x%"PRIx64")",
ri.ri_addr, ri.ri_addr);
eol(0);
if (edit_row[dmode] == print_entry_ndx)
@@ -627,10 +614,10 @@ static int print_quota(struct gfs2_inode *diq)
{
struct gfs2_quota qbuf, q;
int i, error;
-
+
print_gfs2("quota file contents:");
eol(0);
- print_gfs2("quota entries found: %lld.", diq->i_di.di_size / sizeof(q));
+ print_gfs2("quota entries found: %"PRIu64".", diq->i_di.di_size / sizeof(q));
eol(0);
for (i=0; ; i++) {
error = gfs2_readi(diq, (void *)&qbuf, i * sizeof(q), sizeof(qbuf));
diff --git a/gfs2/edit/gfs2hex.c b/gfs2/edit/gfs2hex.c
index 62d5cab5..49607294 100644
--- a/gfs2/edit/gfs2hex.c
+++ b/gfs2/edit/gfs2hex.c
@@ -5,24 +5,21 @@
#include <string.h>
#include <inttypes.h>
#include <sys/types.h>
-#include <linux/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <curses.h>
+#include <uuid.h>
#include "hexedit.h"
#define WANT_GFS_CONVERSION_FUNCTIONS
-#include <linux/gfs2_ondisk.h>
+#include <gfs2_ondisk.h>
#include "extended.h"
#include "gfs2hex.h"
#include "libgfs2.h"
-#ifdef GFS2_HAS_UUID
-#include <uuid.h>
-#endif
#define pv(struct, member, fmt, fmt2) do { \
print_it(" "#member, fmt, fmt2, struct->member); \
@@ -381,10 +378,10 @@ static void gfs2_inum_print2(const char *title,struct gfs2_inum *no)
}
else
printf(" %s:",title);
- pv2(no, no_formal_ino, "%llu", "0x%llx");
+ pv2(no, no_formal_ino, "%"PRIu64, "0x%"PRIx64);
if (!termlines)
printf(" addr:");
- pv2(no, no_addr, "%llu", "0x%llx");
+ pv2(no, no_addr, "%"PRIu64, "0x%"PRIx64);
}
/**
@@ -393,6 +390,8 @@ static void gfs2_inum_print2(const char *title,struct gfs2_inum *no)
*/
static void gfs2_sb_print2(struct gfs2_sb *sbp2)
{
+ char readable_uuid[36+1];
+
gfs2_meta_header_print(&sbp2->sb_header);
pv(sbp2, sb_fs_format, "%u", "0x%x");
@@ -417,14 +416,8 @@ static void gfs2_sb_print2(struct gfs2_sb *sbp2)
gfs2_inum_print2("quota ino ", &gfs1_quota_di);
gfs2_inum_print2("license ", &gfs1_license_di);
}
-#ifdef GFS2_HAS_UUID
- {
- char readable_uuid[36+1];
-
uuid_unparse(sbp2->sb_uuid, readable_uuid);
print_it(" sb_uuid", "%s", NULL, readable_uuid);
- }
-#endif
}
/**
diff --git a/gfs2/edit/hexedit.c b/gfs2/edit/hexedit.c
index f015828c..5c4910fe 100644
--- a/gfs2/edit/hexedit.c
+++ b/gfs2/edit/hexedit.c
@@ -6,7 +6,6 @@
#include <string.h>
#include <inttypes.h>
#include <sys/types.h>
-#include <linux/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
@@ -19,7 +18,7 @@
#include <sys/mount.h>
#include <dirent.h>
-#include <linux/gfs2_ondisk.h>
+#include <gfs2_ondisk.h>
#include "copyright.cf"
#include "hexedit.h"
diff --git a/gfs2/edit/hexedit.h b/gfs2/edit/hexedit.h
index d2992d8e..8b2338e6 100644
--- a/gfs2/edit/hexedit.h
+++ b/gfs2/edit/hexedit.h
@@ -4,7 +4,7 @@
#include <sys/types.h>
#include <inttypes.h>
#include <limits.h>
-#include <linux/gfs2_ondisk.h>
+#include <gfs2_ondisk.h>
#include <string.h>
#include "libgfs2.h"
diff --git a/gfs2/edit/journal.c b/gfs2/edit/journal.c
index 6364761f..f45b4e7b 100644
--- a/gfs2/edit/journal.c
+++ b/gfs2/edit/journal.c
@@ -6,7 +6,6 @@
#include <string.h>
#include <inttypes.h>
#include <sys/types.h>
-#include <linux/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
@@ -19,7 +18,7 @@
#include <sys/mount.h>
#include <dirent.h>
-#include <linux/gfs2_ondisk.h>
+#include <gfs2_ondisk.h>
#include "copyright.cf"
#include "hexedit.h"
@@ -531,8 +530,8 @@ void dump_journal(const char *journal, int tblk)
uint64_t o;
int bmap = 0;
- print_gfs2("rgd: 0x%llx for 0x%x, ", rgd->ri.ri_addr,
- rgd->ri.ri_length);
+ print_gfs2("rgd: 0x%"PRIx64" for 0x%"PRIx32", ",
+ rgd->ri.ri_addr, rgd->ri.ri_length);
o = tblk - rgd->ri.ri_data0;
if (o >= (rgd->bits->bi_start +
rgd->bits->bi_len) * (uint64_t)GFS2_NBBY)
@@ -591,8 +590,8 @@ void dump_journal(const char *journal, int tblk)
check_journal_wrap(lh1.lh_sequence,
&highest_seq);
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: "
- "Flags:%x, Seq: 0x%llx, 1st: 0x%llx, "
- "tail: 0x%llx, last: 0x%llx",
+ "Flags:%x, Seq: 0x%"PRIx64", 1st: 0x%"PRIx64", "
+ "tail: 0x%"PRIx64", last: 0x%"PRIx64"",
abs_block, jb + wrappt,
lh1.lh_flags, lh1.lh_sequence,
lh1.lh_first, lh1.lh_tail,
@@ -607,7 +606,7 @@ void dump_journal(const char *journal, int tblk)
dummy_bh.b_data, lh_flags_field,
(dmode == HEX_MODE));
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: Seq"
- ": 0x%llx, tail: 0x%x, blk: 0x%x [%s]",
+ ": 0x%"PRIx64", tail: 0x%x, blk: 0x%x [%s]",
abs_block, ((jb + wrappt) % j_size)
/ sbd.bsize, lh.lh_sequence,
lh.lh_tail, lh.lh_blkno,
diff --git a/gfs2/edit/savemeta.c b/gfs2/edit/savemeta.c
index 04f1221f..c895e1ec 100644
--- a/gfs2/edit/savemeta.c
+++ b/gfs2/edit/savemeta.c
@@ -7,7 +7,6 @@
#include <stdint.h>
#include <inttypes.h>
#include <sys/types.h>
-#include <linux/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
@@ -17,7 +16,7 @@
#include <sys/ioctl.h>
#include <limits.h>
#include <sys/time.h>
-#include <linux/gfs2_ondisk.h>
+#include <gfs2_ondisk.h>
#include <zlib.h>
#include <time.h>
diff --git a/gfs2/fsck/fs_recovery.c b/gfs2/fsck/fs_recovery.c
index 677abd75..5834cc9e 100644
--- a/gfs2/fsck/fs_recovery.c
+++ b/gfs2/fsck/fs_recovery.c
@@ -121,7 +121,7 @@ static void refresh_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,
}
static int buf_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
- struct gfs2_log_descriptor *ld, __be64 *ptr,
+ struct gfs2_log_descriptor *ld, uint64_t *ptr,
int pass)
{
struct gfs2_sbd *sdp = ip->i_sbd;
@@ -188,7 +188,7 @@ static int buf_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
}
static int revoke_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
- struct gfs2_log_descriptor *ld, __be64 *ptr,
+ struct gfs2_log_descriptor *ld, uint64_t *ptr,
int pass)
{
struct gfs2_sbd *sdp = ip->i_sbd;
@@ -215,7 +215,7 @@ static int revoke_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
continue;
}
while (offset + sizeof(uint64_t) <= sdp->sd_sb.sb_bsize) {
- blkno = be64_to_cpu(*(__be64 *)(bh->b_data + offset));
+ blkno = be64_to_cpu(*(uint64_t *)(bh->b_data + offset));
log_info( _("Journal replay processing revoke for "
"block #%lld (0x%llx) for journal+0x%x\n"),
(unsigned long long)blkno,
@@ -242,7 +242,7 @@ static int revoke_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
static int databuf_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
struct gfs2_log_descriptor *ld,
- __be64 *ptr, int pass)
+ uint64_t *ptr, int pass)
{
struct gfs2_sbd *sdp = ip->i_sbd;
unsigned int blks = be32_to_cpu(ld->ld_data1);
@@ -283,7 +283,7 @@ static int databuf_lo_scan_elements(struct gfs2_inode *ip, unsigned int start,
/* Unescape */
if (esc) {
- __be32 *eptr = (__be32 *)bh_ip->b_data;
+ uint32_t *eptr = (uint32_t *)bh_ip->b_data;
*eptr = cpu_to_be32(GFS2_MAGIC);
}
@@ -315,10 +315,10 @@ static int foreach_descriptor(struct gfs2_inode *ip, unsigned int start,
struct gfs2_log_descriptor *ld;
int error = 0;
uint32_t length;
- __be64 *ptr;
+ uint64_t *ptr;
unsigned int offset = sizeof(struct gfs2_log_descriptor);
- offset += sizeof(__be64) - 1;
- offset &= ~(sizeof(__be64) - 1);
+ offset += sizeof(uint64_t) - 1;
+ offset &= ~(sizeof(uint64_t) - 1);
while (start != end) {
uint32_t check_magic;
@@ -360,7 +360,7 @@ static int foreach_descriptor(struct gfs2_inode *ip, unsigned int start,
brelse(bh);
return -EIO;
}
- ptr = (__be64 *)(bh->b_data + offset);
+ ptr = (uint64_t *)(bh->b_data + offset);
error = databuf_lo_scan_elements(ip, start, ld, ptr, pass);
if (error) {
bmodified(bh);
@@ -429,19 +429,17 @@ static int check_journal_seq_no(struct gfs2_inode *ip, int fix)
prev_seq = lh.lh_sequence;
continue;
}
- log_err( _("Journal block %u (0x%x): sequence no. 0x%llx "
- "out of order.\n"), blk, blk, lh.lh_sequence);
- log_info( _("Low: 0x%llx, High: 0x%llx, Prev: 0x%llx\n"),
- (unsigned long long)lowest_seq,
- (unsigned long long)highest_seq,
- (unsigned long long)prev_seq);
+ log_err(_("Journal block %"PRIu32" (0x%"PRIx32"): sequence no. "
+ "0x%"PRIx64" out of order.\n"), blk, blk, lh.lh_sequence);
+ log_info(_("Low: 0x%"PRIx64", High: 0x%"PRIx64", Prev: 0x%"PRIx64"\n"),
+ lowest_seq, highest_seq, prev_seq);
seq_errors++;
if (!fix)
continue;
highest_seq++;
lh.lh_sequence = highest_seq;
prev_seq = lh.lh_sequence;
- log_warn( _("Renumbering it as 0x%llx\n"), lh.lh_sequence);
+ log_warn(_("Renumbering it as 0x%"PRIx64"\n"), lh.lh_sequence);
block_map(ip, blk, &new, &dblock, NULL, FALSE);
bh = bread(ip->i_sbd, dblock);
gfs2_log_header_out(&lh, bh->b_data);
diff --git a/gfs2/fsck/initialize.c b/gfs2/fsck/initialize.c
index d1c620af..603884eb 100644
--- a/gfs2/fsck/initialize.c
+++ b/gfs2/fsck/initialize.c
@@ -925,7 +925,7 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
if (di->di_num.no_formal_ino == 2) {
if (sdp->sd_sb.sb_master_dir.no_addr)
return;
- log_warn(_("Found system master directory at: 0x%llx.\n"),
+ log_warn(_("Found system master directory at: 0x%"PRIx64".\n"),
di->di_num.no_addr);
sdp->sd_sb.sb_master_dir.no_addr = di->di_num.no_addr;
return;
@@ -940,7 +940,7 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
(di->di_size % sizeof(struct gfs_jindex) == 0))) {
if (fix_md.jiinode || is_journal_copy(ip, bh))
goto out_discard_ip;
- log_warn(_("Found system jindex file at: 0x%llx\n"),
+ log_warn(_("Found system jindex file at: 0x%"PRIx64"\n"),
di->di_num.no_addr);
fix_md.jiinode = ip;
} else if (!sdp->gfs1 && is_dir(di, sdp->gfs1)) {
@@ -954,8 +954,8 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
}
fix_md.jiinode = child_ip;
sdp->sd_sb.sb_master_dir.no_addr = di->di_num.no_addr;
- log_warn(_("Found system master directory at: "
- "0x%llx\n"), di->di_num.no_addr);
+ log_warn(_("Found system master directory at: 0x%"PRIx64"\n"),
+ di->di_num.no_addr);
return;
}
@@ -966,39 +966,38 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
inode_put(&child_ip);
if (fix_md.pinode || is_journal_copy(ip, bh))
goto out_discard_ip;
- log_warn(_("Found system per_node directory at: "
- "0x%llx\n"), ip->i_di.di_num.no_addr);
+ log_warn(_("Found system per_node directory at: 0x%"PRIx64"\n"),
+ ip->i_di.di_num.no_addr);
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;
- log_warn(_("From per_node\'s \'..\' I "
- "backtracked the master directory "
- "to: 0x%llx\n"), inum.no_addr);
+ log_warn(_("Found master directory from per_node/.. "
+ "at 0x%"PRIx64"\n"), inum.no_addr);
}
return;
}
- log_debug(_("Unknown system directory at block 0x%llx\n"),
+ log_debug(_("Unknown system directory at block 0x%"PRIx64"\n"),
di->di_num.no_addr);
goto out_discard_ip;
} else if (!sdp->gfs1 && di->di_size == 8) {
if (fix_md.inum || is_journal_copy(ip, bh))
goto out_discard_ip;
fix_md.inum = ip;
- log_warn(_("Found system inum file at: 0x%llx\n"),
+ log_warn(_("Found system inum file at: 0x%"PRIx64"\n"),
di->di_num.no_addr);
} else if (di->di_size == 24) {
if (fix_md.statfs || is_journal_copy(ip, bh))
goto out_discard_ip;
fix_md.statfs = ip;
- log_warn(_("Found system statfs file at: 0x%llx\n"),
+ log_warn(_("Found system statfs file at: 0x%"PRIx64"\n"),
di->di_num.no_addr);
} else if ((di->di_size % 96) == 0) {
if (fix_md.riinode || is_journal_copy(ip, bh))
goto out_discard_ip;
fix_md.riinode = ip;
- log_warn(_("Found system rindex file at: 0x%llx\n"),
+ log_warn(_("Found system rindex file at: 0x%"PRIx64"\n"),
di->di_num.no_addr);
} else if (!fix_md.qinode && di->di_size >= 176 &&
di->di_num.no_formal_ino >= 12 &&
@@ -1006,7 +1005,7 @@ static void peruse_system_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
if (is_journal_copy(ip, bh))
goto out_discard_ip;
fix_md.qinode = ip;
- log_warn(_("Found system quota file at: 0x%llx\n"),
+ log_warn(_("Found system quota file at: 0x%"PRIx64"\n"),
di->di_num.no_addr);
} else {
out_discard_ip:
@@ -1034,17 +1033,17 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
struct gfs2_buffer_head *root_bh;
if (di->di_num.no_addr == bh->b_blocknr) {
- log_warn(_("Found the root directory at: 0x%llx.\n"),
+ log_warn(_("Found the root directory at: 0x%"PRIx64".\n"),
di->di_num.no_addr);
sdp->sd_sb.sb_root_dir.no_addr = di->di_num.no_addr;
return;
}
- log_warn(_("The root dinode should be at block 0x%llx but it "
+ log_warn(_("The root dinode should be at block 0x%"PRIx64" but it "
"seems to be destroyed.\n"),
- (unsigned long long)di->di_num.no_addr);
+ di->di_num.no_addr);
log_warn(_("Found a copy of the root directory in a journal "
- "at block: 0x%llx.\n"),
- (unsigned long long)bh->b_blocknr);
+ "at block: 0x%"PRIx64".\n"),
+ bh->b_blocknr);
if (!query(_("Do you want to replace the root dinode from the "
"copy? (y/n)"))) {
log_err(_("Damaged root dinode not fixed.\n"));
@@ -1066,10 +1065,9 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
gfs2_lookupi(ip, "..", 2, &parent_ip);
if (parent_ip && parent_ip->i_di.di_num.no_addr ==
ip->i_di.di_num.no_addr) {
- log_warn(_("Found the root directory at: 0x%llx\n"),
+ log_warn(_("Found the root directory at: 0x%"PRIx64"\n"),
ip->i_di.di_num.no_addr);
- sdp->sd_sb.sb_root_dir.no_addr =
- ip->i_di.di_num.no_addr;
+ sdp->sd_sb.sb_root_dir.no_addr = ip->i_di.di_num.no_addr;
inode_put(&parent_ip);
inode_put(&ip);
return;
@@ -1082,8 +1080,8 @@ static void peruse_user_dinode(struct gfs2_sbd *sdp, struct gfs2_dinode *di,
error = dir_search(ip, "..", 2, NULL, &inum);
if (!error && inum.no_addr && inum.no_addr < possible_root) {
possible_root = inum.no_addr;
- log_debug(_("Found a possible root at: 0x%llx\n"),
- (unsigned long long)possible_root);
+ log_debug(_("Found a possible root at: 0x%"PRIx64"\n"),
+ possible_root);
}
inode_put(&ip);
}
@@ -1272,7 +1270,7 @@ 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%llx\n"),
+ 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);
@@ -1282,7 +1280,7 @@ static int sb_repair(struct gfs2_sbd *sdp)
}
sdp->master_dir->i_di.di_num.no_addr =
sdp->sd_sb.sb_master_dir.no_addr;
- log_info(_("Found the root directory at: 0x%llx\n"),
+ 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);
diff --git a/gfs2/fsck/lost_n_found.c b/gfs2/fsck/lost_n_found.c
index 4d5d52c8..1c196a72 100644
--- a/gfs2/fsck/lost_n_found.c
+++ b/gfs2/fsck/lost_n_found.c
@@ -61,11 +61,11 @@ static void add_dotdot(struct gfs2_inode *ip)
bmodified(dip->i_bh);
}
} else {
- log_debug(_("Directory (0x%llx)'s link to parent "
- "(0x%llx) had a formal inode discrepancy: "
- "was 0x%llx, expected 0x%llx\n"),
- (unsigned long long)ip->i_di.di_num.no_addr,
- (unsigned long long)di->dotdot_parent.no_addr,
+ log_debug(_("Directory (0x%"PRIx64")'s link to parent "
+ "(0x%"PRIx64") had a formal inode discrepancy: "
+ "was 0x%"PRIx64", expected 0x%"PRIx64"\n"),
+ ip->i_di.di_num.no_addr,
+ di->dotdot_parent.no_addr,
di->dotdot_parent.no_formal_ino,
dip->i_di.di_num.no_formal_ino);
log_debug(_("The parent directory was not changed.\n"));
@@ -176,7 +176,7 @@ void make_sure_lf_exists(struct gfs2_inode *ip)
*/
int add_inode_to_lf(struct gfs2_inode *ip){
char tmp_name[256];
- __be32 inode_type;
+ uint32_t inode_type;
struct gfs2_sbd *sdp = ip->i_sbd;
int err = 0;
uint32_t mode;
diff --git a/gfs2/fsck/pass1.c b/gfs2/fsck/pass1.c
index 3c2f74fa..84ff9d9b 100644
--- a/gfs2/fsck/pass1.c
+++ b/gfs2/fsck/pass1.c
@@ -2197,7 +2197,7 @@ int pass1(struct gfs2_sbd *sdp)
(unsigned long long)rg_count);
rgd = (struct rgrp_tree *)n;
for (i = 0; i < rgd->ri.ri_length; i++) {
- log_debug( _("rgrp block %lld (0x%llx) "
+ log_debug(_("rgrp block %"PRIu64" (0x%"PRIx64") "
"is now marked as 'rgrp data'\n"),
rgd->ri.ri_addr + i, rgd->ri.ri_addr + i);
if (gfs2_blockmap_set(bl, rgd->ri.ri_addr + i,
diff --git a/gfs2/fsck/pass2.c b/gfs2/fsck/pass2.c
index 763e39a9..e707a108 100644
--- a/gfs2/fsck/pass2.c
+++ b/gfs2/fsck/pass2.c
@@ -1945,7 +1945,7 @@ static int check_pernode_for(int x, struct gfs2_inode *pernode, const char *fn,
else if (multiple && (ip->i_di.di_size % filelen))
valid_size = 0;
if (!valid_size) {
- log_err(_("System file %s has an invalid size. Is %llu, "
+ log_err(_("System file %s has an invalid size. Is %"PRIu64", "
"should be %llu.\n"), fn, ip->i_di.di_size, filelen);
if (!query( _("Rebuild the system file? (y/n) ")))
goto out_good;
diff --git a/gfs2/fsck/rgrepair.c b/gfs2/fsck/rgrepair.c
index 2f145903..134ae940 100644
--- a/gfs2/fsck/rgrepair.c
+++ b/gfs2/fsck/rgrepair.c
@@ -414,11 +414,10 @@ static uint64_t find_next_rgrp_dist(struct gfs2_sbd *sdp, uint64_t blk,
rgrp_dist++;
}
if (found) {
- log_info( _("rgrp found at 0x%llx, length=%d, "
- "used=%llu, free=%d\n"),
+ log_info(_("rgrp found at 0x%"PRIx64", length=%d, "
+ "used=%"PRIu64", free=%"PRIu32"\n"),
prevrgd->ri.ri_addr, length,
- (unsigned long long)used_blocks,
- free_blocks);
+ used_blocks, free_blocks);
break;
}
}
@@ -688,11 +687,10 @@ static int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs,
for (n = osi_first(&sdp->rgcalc), rgi = 0; n; n = next, rgi++) {
next = osi_next(n);
calc_rgd = (struct rgrp_tree *)n;
- log_debug("%d: 0x%llx / %x / 0x%llx"
+ log_debug("%d: 0x%"PRIx64" / %x / 0x%"PRIx64
" / 0x%x / 0x%x\n", rgi + 1,
- (unsigned long long)calc_rgd->ri.ri_addr,
- calc_rgd->ri.ri_length,
- calc_rgd->ri.ri_data0, calc_rgd->ri.ri_data,
+ calc_rgd->ri.ri_addr, calc_rgd->ri.ri_length,
+ calc_rgd->ri.ri_data0, calc_rgd->ri.ri_data,
calc_rgd->ri.ri_bitbytes);
}
*num_rgs = number_of_rgs;
@@ -1085,16 +1083,14 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
if (actual->ri.ri_addr < expected->ri.ri_addr) {
n = next;
discrepancies++;
- log_info(_("%d addr: 0x%llx < 0x%llx * mismatch\n"),
- rg + 1, actual->ri.ri_addr,
- expected->ri.ri_addr);
+ log_info(_("%d addr: 0x%"PRIx64" < 0x%"PRIx64" * mismatch\n"),
+ rg + 1, actual->ri.ri_addr, expected->ri.ri_addr);
continue;
} else if (expected->ri.ri_addr < actual->ri.ri_addr) {
e = enext;
discrepancies++;
- log_info(_("%d addr: 0x%llx > 0x%llx * mismatch\n"),
- rg + 1, actual->ri.ri_addr,
- expected->ri.ri_addr);
+ log_info(_("%d addr: 0x%"PRIx64" > 0x%"PRIx64" * mismatch\n"),
+ rg + 1, actual->ri.ri_addr, expected->ri.ri_addr);
continue;
}
if (!ri_equal(actual->ri, expected->ri, ri_length) ||
@@ -1102,9 +1098,8 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
!ri_equal(actual->ri, expected->ri, ri_data) ||
!ri_equal(actual->ri, expected->ri, ri_bitbytes)) {
discrepancies++;
- log_info(_("%d addr: 0x%llx 0x%llx * has mismatch\n"),
- rg + 1, actual->ri.ri_addr,
- expected->ri.ri_addr);
+ log_info(_("%d addr: 0x%"PRIx64" 0x%"PRIx64" * has mismatch\n"),
+ rg + 1, actual->ri.ri_addr, expected->ri.ri_addr);
}
n = next;
e = enext;
diff --git a/gfs2/include/gfs2_ondisk.h b/gfs2/include/gfs2_ondisk.h
new file mode 100644
index 00000000..0a5a37fa
--- /dev/null
+++ b/gfs2/include/gfs2_ondisk.h
@@ -0,0 +1,535 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
+ * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ */
+
+#ifndef __GFS2_ONDISK_DOT_H__
+#define __GFS2_ONDISK_DOT_H__
+
+#include <stdint.h>
+
+#define GFS2_MAGIC 0x01161970
+#define GFS2_BASIC_BLOCK 512
+#define GFS2_BASIC_BLOCK_SHIFT 9
+
+/* Lock numbers of the LM_TYPE_NONDISK type */
+
+#define GFS2_MOUNT_LOCK 0
+#define GFS2_LIVE_LOCK 1
+#define GFS2_FREEZE_LOCK 2
+#define GFS2_RENAME_LOCK 3
+#define GFS2_CONTROL_LOCK 4
+#define GFS2_MOUNTED_LOCK 5
+
+/* Format numbers for various metadata types */
+
+#define GFS2_FORMAT_NONE 0
+#define GFS2_FORMAT_SB 100
+#define GFS2_FORMAT_RG 200
+#define GFS2_FORMAT_RB 300
+#define GFS2_FORMAT_DI 400
+#define GFS2_FORMAT_IN 500
+#define GFS2_FORMAT_LF 600
+#define GFS2_FORMAT_JD 700
+#define GFS2_FORMAT_LH 800
+#define GFS2_FORMAT_LD 900
+#define GFS2_FORMAT_LB 1000
+#define GFS2_FORMAT_EA 1600
+#define GFS2_FORMAT_ED 1700
+#define GFS2_FORMAT_QC 1400
+/* These are format numbers for entities contained in files */
+#define GFS2_FORMAT_RI 1100
+#define GFS2_FORMAT_DE 1200
+#define GFS2_FORMAT_QU 1500
+/* These are part of the superblock */
+#define GFS2_FORMAT_FS 1801
+#define GFS2_FORMAT_MULTI 1900
+
+/*
+ * An on-disk inode number
+ */
+
+struct gfs2_inum {
+ uint64_t no_formal_ino;
+ uint64_t no_addr;
+};
+
+/*
+ * Generic metadata head structure
+ * Every inplace buffer logged in the journal must start with this.
+ */
+
+#define GFS2_METATYPE_NONE 0
+#define GFS2_METATYPE_SB 1
+#define GFS2_METATYPE_RG 2
+#define GFS2_METATYPE_RB 3
+#define GFS2_METATYPE_DI 4
+#define GFS2_METATYPE_IN 5
+#define GFS2_METATYPE_LF 6
+#define GFS2_METATYPE_JD 7
+#define GFS2_METATYPE_LH 8
+#define GFS2_METATYPE_LD 9
+#define GFS2_METATYPE_LB 12
+#define GFS2_METATYPE_EA 10
+#define GFS2_METATYPE_ED 11
+#define GFS2_METATYPE_QC 14
+
+struct gfs2_meta_header {
+ uint32_t mh_magic;
+ uint32_t mh_type;
+ uint64_t __pad0; /* Was generation number in gfs1 */
+ uint32_t mh_format;
+ /* This union is to keep userspace happy */
+ union {
+ uint32_t mh_jid; /* Was incarnation number in gfs1 */
+ uint32_t __pad1;
+ };
+};
+
+/*
+ * super-block structure
+ *
+ * It's probably good if SIZEOF_SB <= GFS2_BASIC_BLOCK (512 bytes)
+ *
+ * Order is important, need to be able to read old superblocks to do on-disk
+ * version upgrades.
+ */
+
+/* Address of superblock in GFS2 basic blocks */
+#define GFS2_SB_ADDR 128
+
+/* The lock number for the superblock (must be zero) */
+#define GFS2_SB_LOCK 0
+
+/* Requirement: GFS2_LOCKNAME_LEN % 8 == 0
+ Includes: the fencing zero at the end */
+#define GFS2_LOCKNAME_LEN 64
+
+struct gfs2_sb {
+ struct gfs2_meta_header sb_header;
+
+ uint32_t sb_fs_format;
+ uint32_t sb_multihost_format;
+ uint32_t __pad0; /* Was superblock flags in gfs1 */
+
+ uint32_t sb_bsize;
+ uint32_t sb_bsize_shift;
+ uint32_t __pad1; /* Was journal segment size in gfs1 */
+
+ struct gfs2_inum sb_master_dir; /* Was jindex dinode in gfs1 */
+ struct gfs2_inum __pad2; /* Was rindex dinode in gfs1 */
+ struct gfs2_inum sb_root_dir;
+
+ char sb_lockproto[GFS2_LOCKNAME_LEN];
+ char sb_locktable[GFS2_LOCKNAME_LEN];
+
+ struct gfs2_inum __pad3; /* Was quota inode in gfs1 */
+ struct gfs2_inum __pad4; /* Was licence inode in gfs1 */
+#define GFS2_HAS_UUID 1
+ uint8_t sb_uuid[16]; /* The UUID, maybe 0 for backwards compat */
+};
+
+/*
+ * resource index structure
+ */
+
+struct gfs2_rindex {
+ uint64_t ri_addr; /* grp block disk address */
+ uint32_t ri_length; /* length of rgrp header in fs blocks */
+ uint32_t __pad;
+
+ uint64_t ri_data0; /* first data location */
+ uint32_t ri_data; /* num of data blocks in rgrp */
+
+ uint32_t ri_bitbytes; /* number of bytes in data bitmaps */
+
+ uint8_t ri_reserved[64];
+};
+
+/*
+ * resource group header structure
+ */
+
+/* Number of blocks per byte in rgrp */
+#define GFS2_NBBY 4
+#define GFS2_BIT_SIZE 2
+#define GFS2_BIT_MASK 0x00000003
+
+#define GFS2_BLKST_FREE 0
+#define GFS2_BLKST_USED 1
+#define GFS2_BLKST_UNLINKED 2
+#define GFS2_BLKST_DINODE 3
+
+#define GFS2_RGF_JOURNAL 0x00000001
+#define GFS2_RGF_METAONLY 0x00000002
+#define GFS2_RGF_DATAONLY 0x00000004
+#define GFS2_RGF_NOALLOC 0x00000008
+#define GFS2_RGF_TRIMMED 0x00000010
+
+struct gfs2_rgrp_lvb {
+ uint32_t rl_magic;
+ uint32_t rl_flags;
+ uint32_t rl_free;
+ uint32_t rl_dinodes;
+ uint64_t rl_igeneration;
+ uint32_t rl_unlinked;
+ uint32_t __pad;
+};
+
+struct gfs2_rgrp {
+ struct gfs2_meta_header rg_header;
+
+ uint32_t rg_flags;
+ uint32_t rg_free;
+ uint32_t rg_dinodes;
+ union {
+ uint32_t __pad;
+ uint32_t rg_skip; /* Distance to the next rgrp in fs blocks */
+ };
+ uint64_t rg_igeneration;
+ /* The following 3 fields are duplicated from gfs2_rindex to reduce
+ reliance on the rindex */
+ uint64_t rg_data0; /* First data location */
+ uint32_t rg_data; /* Number of data blocks in rgrp */
+ uint32_t rg_bitbytes; /* Number of bytes in data bitmaps */
+ uint32_t rg_crc; /* crc32 of the structure with this field 0 */
+
+ uint8_t rg_reserved[60]; /* Several fields from gfs1 now reserved */
+};
+
+/*
+ * quota structure
+ */
+
+struct gfs2_quota {
+ uint64_t qu_limit;
+ uint64_t qu_warn;
+ uint64_t qu_value;
+ uint8_t qu_reserved[64];
+};
+
+/*
+ * dinode structure
+ */
+
+#define GFS2_MAX_META_HEIGHT 10
+#define GFS2_DIR_MAX_DEPTH 17
+
+#define DT2IF(dt) (((dt) << 12) & S_IFMT)
+#define IF2DT(sif) (((sif) & S_IFMT) >> 12)
+
+enum {
+ gfs2fl_Jdata = 0,
+ gfs2fl_ExHash = 1,
+ gfs2fl_Unused = 2,
+ gfs2fl_EaIndirect = 3,
+ gfs2fl_Directio = 4,
+ gfs2fl_Immutable = 5,
+ gfs2fl_AppendOnly = 6,
+ gfs2fl_NoAtime = 7,
+ gfs2fl_Sync = 8,
+ gfs2fl_System = 9,
+ gfs2fl_TopLevel = 10,
+ gfs2fl_TruncInProg = 29,
+ gfs2fl_InheritDirectio = 30,
+ gfs2fl_InheritJdata = 31,
+};
+
+/* Dinode flags */
+#define GFS2_DIF_JDATA 0x00000001
+#define GFS2_DIF_EXHASH 0x00000002
+#define GFS2_DIF_UNUSED 0x00000004 /* only in gfs1 */
+#define GFS2_DIF_EA_INDIRECT 0x00000008
+#define GFS2_DIF_DIRECTIO 0x00000010
+#define GFS2_DIF_IMMUTABLE 0x00000020
+#define GFS2_DIF_APPENDONLY 0x00000040
+#define GFS2_DIF_NOATIME 0x00000080
+#define GFS2_DIF_SYNC 0x00000100
+#define GFS2_DIF_SYSTEM 0x00000200 /* New in gfs2 */
+#define GFS2_DIF_TOPDIR 0x00000400 /* New in gfs2 */
+#define GFS2_DIF_TRUNC_IN_PROG 0x20000000 /* New in gfs2 */
+#define GFS2_DIF_INHERIT_DIRECTIO 0x40000000 /* only in gfs1 */
+#define GFS2_DIF_INHERIT_JDATA 0x80000000
+
+struct gfs2_dinode {
+ struct gfs2_meta_header di_header;
+
+ struct gfs2_inum di_num;
+
+ uint32_t di_mode; /* mode of file */
+ uint32_t di_uid; /* owner's user id */
+ uint32_t di_gid; /* owner's group id */
+ uint32_t di_nlink; /* number of links to this file */
+ uint64_t di_size; /* number of bytes in file */
+ uint64_t di_blocks; /* number of blocks in file */
+ uint64_t di_atime; /* time last accessed */
+ uint64_t di_mtime; /* time last modified */
+ uint64_t di_ctime; /* time last changed */
+ uint32_t di_major; /* device major number */
+ uint32_t di_minor; /* device minor number */
+
+ /* This section varies from gfs1. Padding added to align with
+ * remainder of dinode
+ */
+ uint64_t di_goal_meta; /* rgrp to alloc from next */
+ uint64_t di_goal_data; /* data block goal */
+ uint64_t di_generation; /* generation number for NFS */
+
+ uint32_t di_flags; /* GFS2_DIF_... */
+ uint32_t di_payload_format; /* GFS2_FORMAT_... */
+ uint16_t __pad1; /* Was ditype in gfs1 */
+ uint16_t di_height; /* height of metadata */
+ uint32_t __pad2; /* Unused incarnation number from gfs1 */
+
+ /* These only apply to directories */
+ uint16_t __pad3; /* Padding */
+ uint16_t di_depth; /* Number of bits in the table */
+ uint32_t di_entries; /* The number of entries in the directory */
+
+ struct gfs2_inum __pad4; /* Unused even in current gfs1 */
+
+ uint64_t di_eattr; /* extended attribute block number */
+ uint32_t di_atime_nsec; /* nsec portion of atime */
+ uint32_t di_mtime_nsec; /* nsec portion of mtime */
+ uint32_t di_ctime_nsec; /* nsec portion of ctime */
+
+ uint8_t di_reserved[44];
+};
+
+/*
+ * directory structure - many of these per directory file
+ */
+
+#define GFS2_FNAMESIZE 255
+#define GFS2_DIRENT_SIZE(name_len) ((sizeof(struct gfs2_dirent) + (name_len) + 7) & ~7)
+#define GFS2_MIN_DIRENT_SIZE (GFS2_DIRENT_SIZE(1))
+
+
+struct gfs2_dirent {
+ struct gfs2_inum de_inum;
+ uint32_t de_hash;
+ uint16_t de_rec_len;
+ uint16_t de_name_len;
+ uint16_t de_type;
+ uint16_t de_rahead;
+ union {
+ uint8_t __pad[12];
+ struct {
+ uint32_t de_cookie; /* ondisk value not used */
+ uint8_t pad3[8];
+ };
+ };
+};
+
+/*
+ * Header of leaf directory nodes
+ */
+
+struct gfs2_leaf {
+ struct gfs2_meta_header lf_header;
+
+ uint16_t lf_depth; /* Depth of leaf */
+ uint16_t lf_entries; /* Number of dirents in leaf */
+ uint32_t lf_dirent_format; /* Format of the dirents */
+ uint64_t lf_next; /* Next leaf, if overflow */
+
+ union {
+ uint8_t lf_reserved[64];
+ struct {
+ uint64_t lf_inode; /* Dir inode number */
+ uint32_t lf_dist; /* Dist from inode on chain */
+ uint32_t lf_nsec; /* Last ins/del usecs */
+ uint64_t lf_sec; /* Last ins/del in secs */
+ uint8_t lf_reserved2[40];
+ };
+ };
+};
+
+/*
+ * Extended attribute header format
+ *
+ * This works in a similar way to dirents. There is a fixed size header
+ * followed by a variable length section made up of the name and the
+ * associated data. In the case of a "stuffed" entry, the value is
+ * inline directly after the name, the ea_num_ptrs entry will be
+ * zero in that case. For non-"stuffed" entries, there will be
+ * a set of pointers (aligned to 8 byte boundary) to the block(s)
+ * containing the value.
+ *
+ * The blocks containing the values and the blocks containing the
+ * extended attribute headers themselves all start with the common
+ * metadata header. Each inode, if it has extended attributes, will
+ * have either a single block containing the extended attribute headers
+ * or a single indirect block pointing to blocks containing the
+ * extended attribute headers.
+ *
+ * The maximum size of the data part of an extended attribute is 64k
+ * so the number of blocks required depends upon block size. Since the
+ * block size also determines the number of pointers in an indirect
+ * block, its a fairly complicated calculation to work out the maximum
+ * number of blocks that an inode may have relating to extended attributes.
+ *
+ */
+
+#define GFS2_EA_MAX_NAME_LEN 255
+#define GFS2_EA_MAX_DATA_LEN 65536
+
+#define GFS2_EATYPE_UNUSED 0
+#define GFS2_EATYPE_USR 1
+#define GFS2_EATYPE_SYS 2
+#define GFS2_EATYPE_SECURITY 3
+
+#define GFS2_EATYPE_LAST 3
+#define GFS2_EATYPE_VALID(x) ((x) <= GFS2_EATYPE_LAST)
+
+#define GFS2_EAFLAG_LAST 0x01 /* last ea in block */
+
+struct gfs2_ea_header {
+ uint32_t ea_rec_len;
+ uint32_t ea_data_len;
+ uint8_t ea_name_len; /* no NULL pointer after the string */
+ uint8_t ea_type; /* GFS2_EATYPE_... */
+ uint8_t ea_flags; /* GFS2_EAFLAG_... */
+ uint8_t ea_num_ptrs;
+ uint32_t __pad;
+};
+
+/*
+ * Log header structure
+ */
+
+#define GFS2_LOG_HEAD_UNMOUNT 0x00000001 /* log is clean */
+#define GFS2_LOG_HEAD_FLUSH_NORMAL 0x00000002 /* normal log flush */
+#define GFS2_LOG_HEAD_FLUSH_SYNC 0x00000004 /* Sync log flush */
+#define GFS2_LOG_HEAD_FLUSH_SHUTDOWN 0x00000008 /* Shutdown log flush */
+#define GFS2_LOG_HEAD_FLUSH_FREEZE 0x00000010 /* Freeze flush */
+#define GFS2_LOG_HEAD_RECOVERY 0x00000020 /* Journal recovery */
+#define GFS2_LOG_HEAD_USERSPACE 0x80000000 /* Written by gfs2-utils */
+
+/* Log flush callers */
+#define GFS2_LFC_SHUTDOWN 0x00000100
+#define GFS2_LFC_JDATA_WPAGES 0x00000200
+#define GFS2_LFC_SET_FLAGS 0x00000400
+#define GFS2_LFC_AIL_EMPTY_GL 0x00000800
+#define GFS2_LFC_AIL_FLUSH 0x00001000
+#define GFS2_LFC_RGRP_GO_SYNC 0x00002000
+#define GFS2_LFC_INODE_GO_SYNC 0x00004000
+#define GFS2_LFC_INODE_GO_INVAL 0x00008000
+#define GFS2_LFC_FREEZE_GO_SYNC 0x00010000
+#define GFS2_LFC_KILL_SB 0x00020000
+#define GFS2_LFC_DO_SYNC 0x00040000
+#define GFS2_LFC_INPLACE_RESERVE 0x00080000
+#define GFS2_LFC_WRITE_INODE 0x00100000
+#define GFS2_LFC_MAKE_FS_RO 0x00200000
+#define GFS2_LFC_SYNC_FS 0x00400000
+#define GFS2_LFC_EVICT_INODE 0x00800000
+#define GFS2_LFC_TRANS_END 0x01000000
+#define GFS2_LFC_LOGD_JFLUSH_REQD 0x02000000
+#define GFS2_LFC_LOGD_AIL_FLUSH_REQD 0x04000000
+
+#define LH_V1_SIZE (offsetofend(struct gfs2_log_header, lh_hash))
+
+struct gfs2_log_header {
+ struct gfs2_meta_header lh_header;
+
+ uint64_t lh_sequence; /* Sequence number of this transaction */
+ uint32_t lh_flags; /* GFS2_LOG_HEAD_... */
+ uint32_t lh_tail; /* Block number of log tail */
+ uint32_t lh_blkno;
+ uint32_t lh_hash; /* crc up to here with this field 0 */
+
+ /* Version 2 additional fields start here */
+ uint32_t lh_crc; /* crc32c from lh_nsec to end of block */
+ uint32_t lh_nsec; /* Nanoseconds of timestamp */
+ uint64_t lh_sec; /* Seconds of timestamp */
+ uint64_t lh_addr; /* Block addr of this log header (absolute) */
+ uint64_t lh_jinode; /* Journal inode number */
+ uint64_t lh_statfs_addr; /* Local statfs inode number */
+ uint64_t lh_quota_addr; /* Local quota change inode number */
+
+ /* Statfs local changes (i.e. diff from global statfs) */
+ uint64_t lh_local_total;
+ uint64_t lh_local_free;
+ uint64_t lh_local_dinodes;
+};
+
+/*
+ * Log type descriptor
+ */
+
+#define GFS2_LOG_DESC_METADATA 300
+/* ld_data1 is the number of metadata blocks in the descriptor.
+ ld_data2 is unused. */
+
+#define GFS2_LOG_DESC_REVOKE 301
+/* ld_data1 is the number of revoke blocks in the descriptor.
+ ld_data2 is unused. */
+
+#define GFS2_LOG_DESC_JDATA 302
+/* ld_data1 is the number of data blocks in the descriptor.
+ ld_data2 is unused. */
+
+struct gfs2_log_descriptor {
+ struct gfs2_meta_header ld_header;
+
+ uint32_t ld_type; /* GFS2_LOG_DESC_... */
+ uint32_t ld_length; /* Number of buffers in this chunk */
+ uint32_t ld_data1; /* descriptor-specific field */
+ uint32_t ld_data2; /* descriptor-specific field */
+
+ uint8_t ld_reserved[32];
+};
+
+/*
+ * Inum Range
+ * Describe a range of formal inode numbers allocated to
+ * one machine to assign to inodes.
+ */
+
+#define GFS2_INUM_QUANTUM 1048576
+
+struct gfs2_inum_range {
+ uint64_t ir_start;
+ uint64_t ir_length;
+};
+
+/*
+ * Statfs change
+ * Describes an change to the pool of free and allocated
+ * blocks.
+ */
+
+struct gfs2_statfs_change {
+ uint64_t sc_total;
+ uint64_t sc_free;
+ uint64_t sc_dinodes;
+};
+
+/*
+ * Quota change
+ * Describes an allocation change for a particular
+ * user or group.
+ */
+
+#define GFS2_QCF_USER 0x00000001
+
+struct gfs2_quota_change {
+ uint64_t qc_change;
+ uint32_t qc_flags; /* GFS2_QCF_... */
+ uint32_t qc_id;
+};
+
+struct gfs2_quota_lvb {
+ uint32_t qb_magic;
+ uint32_t __pad;
+ uint64_t qb_limit; /* Hard limit of # blocks to alloc */
+ uint64_t qb_warn; /* Warn user when alloc is above this # */
+ uint64_t qb_value; /* Current # blocks allocated */
+};
+
+#endif /* __GFS2_ONDISK_DOT_H__ */
diff --git a/gfs2/libgfs2/buf.c b/gfs2/libgfs2/buf.c
index 92cd393d..aec778a5 100644
--- a/gfs2/libgfs2/buf.c
+++ b/gfs2/libgfs2/buf.c
@@ -11,7 +11,6 @@
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
-#include <linux/types.h>
#include "libgfs2.h"
diff --git a/gfs2/libgfs2/device_geometry.c b/gfs2/libgfs2/device_geometry.c
index 1303f11b..72f9c7e4 100644
--- a/gfs2/libgfs2/device_geometry.c
+++ b/gfs2/libgfs2/device_geometry.c
@@ -11,7 +11,6 @@
#include <unistd.h>
#include <errno.h>
#include <sys/ioctl.h>
-#include <linux/types.h>
#include <linux/fs.h>
#include "libgfs2.h"
diff --git a/gfs2/libgfs2/fs_geometry.c b/gfs2/libgfs2/fs_geometry.c
index df8a13a9..09504c51 100644
--- a/gfs2/libgfs2/fs_geometry.c
+++ b/gfs2/libgfs2/fs_geometry.c
@@ -11,7 +11,6 @@
#include <unistd.h>
#include <errno.h>
-#include <linux/types.h>
#include "libgfs2.h"
#include "config.h"
diff --git a/gfs2/libgfs2/fs_ops.c b/gfs2/libgfs2/fs_ops.c
index 7e87e435..cbf6de88 100644
--- a/gfs2/libgfs2/fs_ops.c
+++ b/gfs2/libgfs2/fs_ops.c
@@ -11,7 +11,6 @@
#include <unistd.h>
#include <errno.h>
-#include <linux/types.h>
#include "libgfs2.h"
#include "rgrp.h"
@@ -1029,9 +1028,7 @@ void dir_split_leaf(struct gfs2_inode *dip, uint32_t start, uint64_t leaf_no,
oleaf->lf_depth = cpu_to_be16(oleaf->lf_depth);
nleaf->lf_depth = oleaf->lf_depth;
-#ifdef GFS2_HAS_LEAF_HINTS
nleaf->lf_inode = cpu_to_be64(dip->i_di.di_num.no_addr);
-#endif
dip->i_di.di_blocks++;
bmodified(dip->i_bh);
@@ -1231,9 +1228,7 @@ restart:
nleaf = (struct gfs2_leaf *)nbh->b_data;
nleaf->lf_depth = leaf->lf_depth;
nleaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
-#ifdef GFS2_HAS_LEAF_HINTS
nleaf->lf_inode = cpu_to_be64(dip->i_di.di_num.no_addr);
-#endif
err = dirent_alloc(dip, nbh, len, &dent);
if (err)
return err;
@@ -1285,9 +1280,7 @@ static void dir_make_exhash(struct gfs2_inode *dip)
leaf = (struct gfs2_leaf *)bh->b_data;
leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
leaf->lf_entries = cpu_to_be16(dip->i_di.di_entries);
-#ifdef GFS2_HAS_LEAF_HINTS
leaf->lf_inode = cpu_to_be64(dip->i_di.di_num.no_addr);
-#endif
buffer_copy_tail(sdp, bh, sizeof(struct gfs2_leaf),
dip->i_bh, sizeof(struct gfs2_dinode));
diff --git a/gfs2/libgfs2/gfs1.c b/gfs2/libgfs2/gfs1.c
index b91cce5e..1fee25c9 100644
--- a/gfs2/libgfs2/gfs1.c
+++ b/gfs2/libgfs2/gfs1.c
@@ -10,8 +10,7 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
-#include <linux/types.h>
-#include <linux/gfs2_ondisk.h>
+#include <gfs2_ondisk.h>
#include "osi_list.h"
#include "libgfs2.h"
diff --git a/gfs2/libgfs2/lang.c b/gfs2/libgfs2/lang.c
index 62ad2ab7..c56091f1 100644
--- a/gfs2/libgfs2/lang.c
+++ b/gfs2/libgfs2/lang.c
@@ -6,12 +6,10 @@
#include <errno.h>
#include <limits.h>
#include <ctype.h>
+#include <uuid.h>
#include "lang.h"
#include "parser.h"
-#ifdef GFS2_HAS_UUID
-#include <uuid.h>
-#endif
const char* ast_type_string[] = {
[AST_NONE] = "NONE",
@@ -315,14 +313,12 @@ static int field_print(const struct gfs2_buffer_head *bh, const struct lgfs2_met
printf("%s\t%"PRIu64"\t%u\t%u\t%s\t", mtype->name, bh->b_blocknr, field->offset, field->length, field->name);
if (field->flags & LGFS2_MFF_UUID) {
-#ifdef GFS2_HAS_UUID
char readable_uuid[36+1];
uuid_t uuid;
memcpy(uuid, fieldp, sizeof(uuid_t));
uuid_unparse(uuid, readable_uuid);
printf("'%s'\n", readable_uuid);
-#endif
} else if (field->flags & LGFS2_MFF_STRING) {
printf("'%s'\n", fieldp);
} else {
@@ -450,7 +446,6 @@ static int ast_field_set(struct gfs2_buffer_head *bh, const struct lgfs2_metafie
int err = 0;
if (field->flags & LGFS2_MFF_UUID) {
-#ifdef GFS2_HAS_UUID
uuid_t uuid;
if (uuid_parse(val->ast_str, uuid) != 0) {
@@ -458,10 +453,6 @@ static int ast_field_set(struct gfs2_buffer_head *bh, const struct lgfs2_metafie
return AST_INTERP_INVAL;
}
err = lgfs2_field_assign(bh->b_data, field, uuid);
-#else
- fprintf(stderr, "No UUID support\n");
- err = 1;
-#endif
} else if (field->flags & LGFS2_MFF_STRING) {
err = lgfs2_field_assign(bh->b_data, field, val->ast_str);
} else {
diff --git a/gfs2/libgfs2/libgfs2.h b/gfs2/libgfs2/libgfs2.h
index f75ff1e0..ce84d831 100644
--- a/gfs2/libgfs2/libgfs2.h
+++ b/gfs2/libgfs2/libgfs2.h
@@ -8,13 +8,12 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/uio.h>
-#include <linux/types.h>
#include <linux/limits.h>
#include <endian.h>
#include <byteswap.h>
#include <mntent.h>
-#include <linux/gfs2_ondisk.h>
+#include <gfs2_ondisk.h>
#include "osi_list.h"
#include "osi_tree.h"
@@ -507,43 +506,43 @@ struct gfs_dinode {
struct gfs2_inum di_num; /* formal inode # and block address */
- __be32 di_mode; /* mode of file */
- __be32 di_uid; /* owner's user id */
- __be32 di_gid; /* owner's group id */
- __be32 di_nlink; /* number (qty) of links to this file */
- __be64 di_size; /* number (qty) of bytes in file */
- __be64 di_blocks; /* number (qty) of blocks in file */
- __be64 di_atime; /* time last accessed */
- __be64 di_mtime; /* time last modified */
- __be64 di_ctime; /* time last changed */
+ uint32_t di_mode; /* mode of file */
+ uint32_t di_uid; /* owner's user id */
+ uint32_t di_gid; /* owner's group id */
+ uint32_t di_nlink; /* number (qty) of links to this file */
+ uint64_t di_size; /* number (qty) of bytes in file */
+ uint64_t di_blocks; /* number (qty) of blocks in file */
+ uint64_t di_atime; /* time last accessed */
+ uint64_t di_mtime; /* time last modified */
+ uint64_t di_ctime; /* time last changed */
/* Non-zero only for character or block device nodes */
- __be32 di_major; /* device major number */
- __be32 di_minor; /* device minor number */
+ uint32_t di_major; /* device major number */
+ uint32_t di_minor; /* device minor number */
/* Block allocation strategy */
- __be64 di_rgrp; /* dinode rgrp block number */
- __be64 di_goal_rgrp; /* rgrp to alloc from next */
- __be32 di_goal_dblk; /* data block goal */
- __be32 di_goal_mblk; /* metadata block goal */
+ uint64_t di_rgrp; /* dinode rgrp block number */
+ uint64_t di_goal_rgrp; /* rgrp to alloc from next */
+ uint32_t di_goal_dblk; /* data block goal */
+ uint32_t di_goal_mblk; /* metadata block goal */
- __be32 di_flags; /* GFS_DIF_... */
+ uint32_t di_flags; /* GFS_DIF_... */
/* struct gfs_rindex, struct gfs_jindex, or struct gfs_dirent */
- __be32 di_payload_format; /* GFS_FORMAT_... */
- __be16 di_type; /* GFS_FILE_... type of file */
- __be16 di_height; /* height of metadata (0 == stuffed) */
- __be32 di_incarn; /* incarnation (unused, see gfs_meta_header) */
- __be16 di_pad;
+ uint32_t di_payload_format; /* GFS_FORMAT_... */
+ uint16_t di_type; /* GFS_FILE_... type of file */
+ uint16_t di_height; /* height of metadata (0 == stuffed) */
+ uint32_t di_incarn; /* incarnation (unused, see gfs_meta_header) */
+ uint16_t di_pad;
/* These only apply to directories */
- __be16 di_depth; /* Number of bits in the table */
- __be32 di_entries; /* The # (qty) of entries in the directory */
+ uint16_t di_depth; /* Number of bits in the table */
+ uint32_t di_entries; /* The # (qty) of entries in the directory */
/* This formed an on-disk chain of unused dinodes */
struct gfs2_inum di_next_unused; /* used in old versions only */
- __be64 di_eattr; /* extended attribute block number */
+ uint64_t di_eattr; /* extended attribute block number */
char di_reserved[56];
};
@@ -553,13 +552,13 @@ struct gfs_sb {
in order to support on-disk version upgrades */
struct gfs2_meta_header sb_header;
- __be32 sb_fs_format; /* GFS_FORMAT_FS (on-disk version) */
- __be32 sb_multihost_format; /* GFS_FORMAT_MULTI */
- __be32 sb_flags; /* ?? */
+ uint32_t sb_fs_format; /* GFS_FORMAT_FS (on-disk version) */
+ uint32_t sb_multihost_format; /* GFS_FORMAT_MULTI */
+ uint32_t sb_flags; /* ?? */
- __be32 sb_bsize; /* fundamental FS block size in bytes */
- __be32 sb_bsize_shift; /* log2(sb_bsize) */
- __be32 sb_seg_size; /* Journal segment size in FS blocks */
+ uint32_t sb_bsize; /* fundamental FS block size in bytes */
+ uint32_t sb_bsize_shift; /* log2(sb_bsize) */
+ uint32_t sb_seg_size; /* Journal segment size in FS blocks */
/* These special inodes do not appear in any on-disk directory. */
struct gfs2_inum sb_jindex_di; /* journal index inode */
@@ -580,17 +579,17 @@ struct gfs_sb {
struct gfs_rgrp {
struct gfs2_meta_header rg_header;
- __be32 rg_flags;
- __be32 rg_free; /* Number (qty) of free data blocks */
+ uint32_t rg_flags;
+ uint32_t rg_free; /* Number (qty) of free data blocks */
/* Dinodes are USEDMETA, but are handled separately from other METAs */
- __be32 rg_useddi; /* Number (qty) of dinodes (used or free) */
- __be32 rg_freedi; /* Number (qty) of unused (free) dinodes */
+ uint32_t rg_useddi; /* Number (qty) of dinodes (used or free) */
+ uint32_t rg_freedi; /* Number (qty) of unused (free) dinodes */
struct gfs2_inum rg_freedi_list; /* 1st block in chain of free dinodes */
/* These META statistics do not include dinodes (used or free) */
- __be32 rg_usedmeta; /* Number (qty) of used metadata blocks */
- __be32 rg_freemeta; /* Number (qty) of unused metadata blocks */
+ uint32_t rg_usedmeta; /* Number (qty) of used metadata blocks */
+ uint32_t rg_freemeta; /* Number (qty) of unused metadata blocks */
char rg_reserved[64];
};
@@ -598,22 +597,22 @@ struct gfs_rgrp {
struct gfs_log_header {
struct gfs2_meta_header lh_header;
- __be32 lh_flags; /* GFS_LOG_HEAD_... */
- __be32 lh_pad;
+ uint32_t lh_flags; /* GFS_LOG_HEAD_... */
+ uint32_t lh_pad;
- __be64 lh_first; /* Block number of first header in this trans */
- __be64 lh_sequence; /* Sequence number of this transaction */
+ uint64_t lh_first; /* Block number of first header in this trans */
+ uint64_t lh_sequence; /* Sequence number of this transaction */
- __be64 lh_tail; /* Block number of log tail */
- __be64 lh_last_dump; /* Block number of last dump */
+ uint64_t lh_tail; /* Block number of log tail */
+ uint64_t lh_last_dump; /* Block number of last dump */
uint8_t lh_reserved[64];
};
struct gfs_jindex {
- __be64 ji_addr; /* starting block of the journal */
- __be32 ji_nsegment; /* number (quantity) of segments in journal */
- __be32 ji_pad;
+ uint64_t ji_addr; /* starting block of the journal */
+ uint32_t ji_nsegment; /* number (quantity) of segments in journal */
+ uint32_t ji_pad;
uint8_t ji_reserved[64];
};
@@ -621,10 +620,10 @@ struct gfs_jindex {
struct gfs_log_descriptor {
struct gfs2_meta_header ld_header;
- __be32 ld_type; /* GFS_LOG_DESC_... Type of this log chunk */
- __be32 ld_length; /* Number of buffers in this chunk */
- __be32 ld_data1; /* descriptor-specific field */
- __be32 ld_data2; /* descriptor-specific field */
+ uint32_t ld_type; /* GFS_LOG_DESC_... Type of this log chunk */
+ uint32_t ld_length; /* Number of buffers in this chunk */
+ uint32_t ld_data1; /* descriptor-specific field */
+ uint32_t ld_data2; /* descriptor-specific field */
uint8_t ld_reserved[64];
};
@@ -740,9 +739,7 @@ extern void gfs2_dirent_out(struct gfs2_dirent *de, char *buf);
extern void gfs2_leaf_in(struct gfs2_leaf *lf, char *buf);
extern void gfs2_leaf_out(struct gfs2_leaf *lf, char *buf);
extern void gfs2_ea_header_in(struct gfs2_ea_header *ea, char *buf);
-extern void gfs2_log_header_v1_in(struct gfs2_log_header *lh, char *buf);
extern void gfs2_log_header_in(struct gfs2_log_header *lh, char *buf);
-extern void gfs2_log_header_v1_out(struct gfs2_log_header *lh, char *buf);
extern void gfs2_log_header_out(struct gfs2_log_header *lh, char *buf);
extern void gfs2_log_descriptor_in(struct gfs2_log_descriptor *ld, char *buf);
extern void gfs2_log_descriptor_out(struct gfs2_log_descriptor *ld, char *buf);
diff --git a/gfs2/libgfs2/meta.c b/gfs2/libgfs2/meta.c
index 1da74146..42325077 100644
--- a/gfs2/libgfs2/meta.c
+++ b/gfs2/libgfs2/meta.c
@@ -1,12 +1,9 @@
#include <stdint.h>
#include <string.h>
+#include <uuid.h>
#include "libgfs2.h"
#include "clusterautoconfig.h"
-#ifdef GFS2_HAS_UUID
-#include <uuid.h>
-#endif
-
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
#define SYM(x) { x, #x, 0 },
#define PREFIX_SYM(p,x) { p##x, #p #x, sizeof #p - 1 },
@@ -72,7 +69,6 @@ const unsigned lgfs2_di_flag_size = ARRAY_SIZE(lgfs2_di_flags);
const struct lgfs2_symbolic lgfs2_lh_flags[] = {
PREFIX_SYM(GFS2_LOG_HEAD_, UNMOUNT)
-#ifdef GFS2_HAS_LH_V2
PREFIX_SYM(GFS2_LOG_HEAD_FLUSH_, NORMAL)
PREFIX_SYM(GFS2_LOG_HEAD_FLUSH_, SYNC)
PREFIX_SYM(GFS2_LOG_HEAD_FLUSH_, SHUTDOWN)
@@ -100,7 +96,6 @@ PREFIX_SYM(GFS2_LFC_, EVICT_INODE)
PREFIX_SYM(GFS2_LFC_, TRANS_END)
PREFIX_SYM(GFS2_LFC_, LOGD_JFLUSH_REQD)
PREFIX_SYM(GFS2_LFC_, LOGD_AIL_FLUSH_REQD)
-#endif
};
const unsigned int lgfs2_lh_flag_size = ARRAY_SIZE(lgfs2_lh_flags);
@@ -183,9 +178,7 @@ F(sb_lockproto, .flags = LGFS2_MFF_STRING)
F(sb_locktable, .flags = LGFS2_MFF_STRING)
INR(__pad3, .points_to = (1 << LGFS2_MT_GFS2_DINODE))
INR(__pad4, .points_to = (1 << LGFS2_MT_GFS2_DINODE))
-#ifdef GFS2_HAS_UUID
F(sb_uuid, .flags = LGFS2_MFF_UUID)
-#endif
};
#undef STRUCT
@@ -230,18 +223,12 @@ MH(rg_header)
F(rg_flags)
F(rg_free, .flags = LGFS2_MFF_FSBLOCKS)
F(rg_dinodes, .flags = LGFS2_MFF_FSBLOCKS)
-#ifdef GFS2_HAS_RG_SKIP
FP(rg_skip, .points_to = (1 << LGFS2_MT_GFS2_RGRP))
-#else
-RF(__pad)
-#endif
F(rg_igeneration)
-#ifdef GFS2_HAS_RG_RI_FIELDS
FP(rg_data0, .points_to = ANY_GFS2_BLOCK|(1 << LGFS2_MT_FREE))
F(rg_data, .flags = LGFS2_MFF_FSBLOCKS)
F(rg_bitbytes, .flags = LGFS2_MFF_BYTES)
F(rg_crc, .flags = LGFS2_MFF_CHECK)
-#endif
RF(rg_reserved)
};
@@ -363,15 +350,11 @@ F(lf_depth)
F(lf_entries)
F(lf_dirent_format)
F(lf_next)
-#ifdef GFS2_HAS_LEAF_HINTS
FP(lf_inode, .points_to = (1 << LGFS2_MT_GFS2_DINODE))
F(lf_dist)
F(lf_nsec, .flags = LGFS2_MFF_NSECS)
F(lf_sec, .flags = LGFS2_MFF_SECS)
RF(lf_reserved2)
-#else
-RF(lf_reserved)
-#endif
};
#undef STRUCT
@@ -392,7 +375,6 @@ F(lh_flags, .flags = LGFS2_MFF_MASK, .symtab = lgfs2_lh_flags, .nsyms = ARRAY_SI
F(lh_tail)
F(lh_blkno)
F(lh_hash, .flags = LGFS2_MFF_CHECK)
-#ifdef GFS2_HAS_LH_V2
F(lh_crc, .flags = LGFS2_MFF_CHECK)
F(lh_nsec, .flags = LGFS2_MFF_NSECS)
F(lh_sec, .flags = LGFS2_MFF_SECS)
@@ -403,7 +385,6 @@ FP(lh_quota_addr, .points_to = (1 << LGFS2_MT_GFS2_DINODE))
F(lh_local_total, .flags = LGFS2_MFF_FSBLOCKS)
F(lh_local_free, .flags = LGFS2_MFF_FSBLOCKS)
F(lh_local_dinodes, .flags = LGFS2_MFF_FSBLOCKS)
-#endif
};
#undef STRUCT
@@ -486,17 +467,9 @@ F(de_hash, .flags = LGFS2_MFF_CHECK)
F(de_rec_len, .flags = LGFS2_MFF_BYTES)
F(de_name_len, .flags = LGFS2_MFF_BYTES)
F(de_type)
-#ifdef GFS2_HAS_DE_RAHEAD
F(de_rahead)
-#ifdef GFS2_HAS_DE_COOKIE
F(de_cookie)
RF(pad3)
-#else
-RF(pad2)
-#endif /* GFS2_HAS_DE_COOKIE */
-#else
-RF(__pad)
-#endif /* GFS2_HAS_DE_RAHEAD */
};
#undef STRUCT
@@ -935,14 +908,12 @@ int lgfs2_field_str(char *str, const size_t size, const char *blk, const struct
return 1;
if (field->flags & LGFS2_MFF_UUID) {
-#ifdef GFS2_HAS_UUID
char readable_uuid[36+1];
uuid_t uuid;
memcpy(uuid, fieldp, sizeof(uuid_t));
uuid_unparse(uuid, readable_uuid);
snprintf(str, size, "%s", readable_uuid);
-#endif
} else if (field->flags & LGFS2_MFF_STRING) {
snprintf(str, size, "%s", fieldp);
} else {
diff --git a/gfs2/libgfs2/ondisk.c b/gfs2/libgfs2/ondisk.c
index 648a9142..19e98db3 100644
--- a/gfs2/libgfs2/ondisk.c
+++ b/gfs2/libgfs2/ondisk.c
@@ -6,11 +6,8 @@
#include <stdint.h>
#include <inttypes.h>
#include <ctype.h>
-#include <linux/types.h>
-#include "libgfs2.h"
-#ifdef GFS2_HAS_UUID
#include <uuid.h>
-#endif
+#include "libgfs2.h"
#define pv(struct, member, fmt, fmt2) do { \
print_it(" "#member, fmt, fmt2, struct->member); \
@@ -60,8 +57,8 @@ void gfs2_inum_out(const struct gfs2_inum *no, char *buf)
void gfs2_inum_print(const struct gfs2_inum *no)
{
- pv(no, no_formal_ino, "%llu", "0x%llx");
- pv(no, no_addr, "%llu", "0x%llx");
+ pv(no, no_formal_ino, "%"PRIu64, "0x%"PRIx64);
+ pv(no, no_addr, "%"PRIu64, "0x%"PRIx64);
}
void gfs2_meta_header_in(struct gfs2_meta_header *mh, char *buf)
@@ -87,8 +84,8 @@ void gfs2_meta_header_out(const struct gfs2_meta_header *mh, char *buf)
void gfs2_meta_header_print(const struct gfs2_meta_header *mh)
{
pv(mh, mh_magic, "0x%08X", NULL);
- pv(mh, mh_type, "%u", "0x%x");
- pv(mh, mh_format, "%u", "0x%x");
+ pv(mh, mh_type, "%"PRIu32, "0x%"PRIx32);
+ pv(mh, mh_format, "%"PRIu32, "0x%"PRIx32);
}
void gfs2_sb_in(struct gfs2_sb *sb, char *buf)
@@ -113,9 +110,7 @@ void gfs2_sb_in(struct gfs2_sb *sb, char *buf)
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 */
-#ifdef GFS2_HAS_UUID
CPIN_08(sb, str, sb_uuid, sizeof(sb->sb_uuid));
-#endif
}
void gfs2_sb_out(const struct gfs2_sb *sb, char *buf)
@@ -140,20 +135,20 @@ void gfs2_sb_out(const struct gfs2_sb *sb, char *buf)
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 */
-#ifdef GFS2_HAS_UUID
memcpy(str->sb_uuid, sb->sb_uuid, 16);
-#endif
}
void gfs2_sb_print(const struct gfs2_sb *sb)
{
+ char readable_uuid[36+1];
+
gfs2_meta_header_print(&sb->sb_header);
- pv(sb, sb_fs_format, "%u", "0x%x");
- pv(sb, sb_multihost_format, "%u", "0x%x");
+ pv(sb, sb_fs_format, "%"PRIu32, "0x%"PRIx32);
+ pv(sb, sb_multihost_format, "%"PRIu32, "0x%"PRIx32);
- pv(sb, sb_bsize, "%u", "0x%x");
- pv(sb, sb_bsize_shift, "%u", "0x%x");
+ pv(sb, sb_bsize, "%"PRIu32, "0x%"PRIx32);
+ pv(sb, sb_bsize_shift, "%"PRIu32, "0x%"PRIx32);
gfs2_inum_print(&sb->sb_master_dir);
gfs2_inum_print(&sb->sb_root_dir);
@@ -161,14 +156,8 @@ void gfs2_sb_print(const struct gfs2_sb *sb)
pv(sb, sb_lockproto, "%s", NULL);
pv(sb, sb_locktable, "%s", NULL);
-#ifdef GFS2_HAS_UUID
- {
- char readable_uuid[36+1];
-
uuid_unparse(sb->sb_uuid, readable_uuid);
print_it(" uuid", "%36s", NULL, readable_uuid);
- }
-#endif
}
void gfs2_rindex_in(struct gfs2_rindex *ri, char *buf)
@@ -202,13 +191,11 @@ void gfs2_rindex_out(const struct gfs2_rindex *ri, char *buf)
void gfs2_rindex_print(const struct gfs2_rindex *ri)
{
- pv(ri, ri_addr, "%llu", "0x%llx");
- pv(ri, ri_length, "%u", "0x%x");
-
- pv(ri, ri_data0, "%llu", "0x%llx");
- pv(ri, ri_data, "%u", "0x%x");
-
- pv(ri, ri_bitbytes, "%u", "0x%x");
+ pv(ri, ri_addr, "%"PRIu64, "0x%"PRIx64);
+ pv(ri, ri_length, "%"PRIu32, "0x%"PRIx32);
+ pv(ri, ri_data0, "%"PRIu64, "0x%"PRIx64);
+ pv(ri, ri_data, "%"PRIu32, "0x%"PRIx32);
+ pv(ri, ri_bitbytes, "%"PRIu32, "0x%"PRIx32);
}
void gfs2_rgrp_in(struct gfs2_rgrp *rg, char *buf)
@@ -219,18 +206,12 @@ void gfs2_rgrp_in(struct gfs2_rgrp *rg, char *buf)
CPIN_32(rg, str, rg_flags);
CPIN_32(rg, str, rg_free);
CPIN_32(rg, str, rg_dinodes);
-#ifdef GFS2_HAS_RG_SKIP
CPIN_32(rg, str, rg_skip);
-#else
- CPIN_32(rg, str, __pad);
-#endif
CPIN_64(rg, str, rg_igeneration);
-#ifdef GFS2_HAS_RG_RI_FIELDS
CPIN_64(rg, str, rg_data0);
CPIN_32(rg, str, rg_data);
CPIN_32(rg, str, rg_bitbytes);
CPIN_32(rg, str, rg_crc);
-#endif
CPIN_08(rg, str, rg_reserved, sizeof(rg->rg_reserved));
}
@@ -242,41 +223,27 @@ void gfs2_rgrp_out(const struct gfs2_rgrp *rg, char *buf)
CPOUT_32(rg, str, rg_flags);
CPOUT_32(rg, str, rg_free);
CPOUT_32(rg, str, rg_dinodes);
-#ifdef GFS2_HAS_RG_SKIP
CPOUT_32(rg, str, rg_skip);
-#else
- CPOUT_32(rg, str, __pad);
-#endif
CPOUT_64(rg, str, rg_igeneration);
-#ifdef GFS2_HAS_RG_RI_FIELDS
CPOUT_64(rg, str, rg_data0);
CPOUT_32(rg, str, rg_data);
CPOUT_32(rg, str, rg_bitbytes);
CPOUT_08(rg, str, rg_reserved, sizeof(rg->rg_reserved));
lgfs2_rgrp_crc_set(buf);
-#else
- CPOUT_08(rg, str, rg_reserved, sizeof(rg->rg_reserved));
-#endif
}
void gfs2_rgrp_print(const struct gfs2_rgrp *rg)
{
gfs2_meta_header_print(&rg->rg_header);
- pv(rg, rg_flags, "%u", "0x%x");
- pv(rg, rg_free, "%u", "0x%x");
- pv(rg, rg_dinodes, "%u", "0x%x");
-#ifdef GFS2_HAS_RG_SKIP
- pv(rg, rg_skip, "%u", "0x%x");
-#else
- pv(rg, __pad, "%u", "0x%x");
-#endif
- pv(rg, rg_igeneration, "%llu", "0x%llx");
-#ifdef GFS2_HAS_RG_RI_FIELDS
- pv(rg, rg_data0, "%llu", "0x%llx");
- pv(rg, rg_data, "%u", "0x%x");
- pv(rg, rg_bitbytes, "%u", "0x%x");
- pv(rg, rg_crc, "%u", "0x%x");
-#endif
+ pv(rg, rg_flags, "%"PRIu32, "0x%"PRIx32);
+ pv(rg, rg_free, "%"PRIu32, "0x%"PRIx32);
+ pv(rg, rg_dinodes, "%"PRIu32, "0x%"PRIx32);
+ pv(rg, rg_skip, "%"PRIu32, "0x%"PRIx32);
+ pv(rg, rg_igeneration, "%"PRIu64, "0x%"PRIx64);
+ pv(rg, rg_data0, "%"PRIu64, "0x%"PRIx64);
+ pv(rg, rg_data, "%"PRIu32, "0x%"PRIx32);
+ pv(rg, rg_bitbytes, "%"PRIu32, "0x%"PRIx32);
+ pv(rg, rg_crc, "%"PRIu32, "0x%"PRIx32);
}
void gfs2_quota_in(struct gfs2_quota *qu, char *buf)
@@ -301,9 +268,9 @@ void gfs2_quota_out(struct gfs2_quota *qu, char *buf)
void gfs2_quota_print(const struct gfs2_quota *qu)
{
- pv(qu, qu_limit, "%llu", "0x%llx");
- pv(qu, qu_warn, "%llu", "0x%llx");
- pv(qu, qu_value, "%lld", "0x%llx");
+ pv(qu, qu_limit, "%"PRIu64, "0x%"PRIx64);
+ pv(qu, qu_warn, "%"PRIu64, "0x%"PRIx64);
+ pv(qu, qu_value, "%"PRId64, "0x%"PRIx64);
}
void gfs2_dinode_in(struct gfs2_dinode *di, char *buf)
@@ -382,28 +349,27 @@ void gfs2_dinode_print(const struct gfs2_dinode *di)
gfs2_inum_print(&di->di_num);
pv(di, di_mode, "0%o", NULL);
- pv(di, di_uid, "%u", "0x%x");
- pv(di, di_gid, "%u", "0x%x");
- pv(di, di_nlink, "%u", "0x%x");
- pv(di, di_size, "%llu", "0x%llx");
- pv(di, di_blocks, "%llu", "0x%llx");
- pv(di, di_atime, "%lld", "0x%llx");
- pv(di, di_mtime, "%lld", "0x%llx");
- pv(di, di_ctime, "%lld", "0x%llx");
- pv(di, di_major, "%u", "0x%llx");
- pv(di, di_minor, "%u", "0x%llx");
-
- pv(di, di_goal_meta, "%llu", "0x%llx");
- pv(di, di_goal_data, "%llu", "0x%llx");
-
+ pv(di, di_uid, "%"PRIu32, "0x%"PRIx32);
+ pv(di, di_gid, "%"PRIu32, "0x%"PRIx32);
+ pv(di, di_nlink, "%"PRIu32, "0x%"PRIx32);
+ pv(di, di_size, "%"PRIu64, "0x%"PRIx64);
+ pv(di, di_blocks, "%"PRIu64, "0x%"PRIx64);
+ pv(di, di_atime, "%"PRId64, "0x%"PRIx64);
+ pv(di, di_mtime, "%"PRId64, "0x%"PRIx64);
+ pv(di, di_ctime, "%"PRId64, "0x%"PRIx64);
+ pv(di, di_major, "%"PRIu32, "0x%"PRIx32);
+ pv(di, di_minor, "%"PRIu32, "0x%"PRIx32);
+ pv(di, di_goal_meta, "%"PRIu64, "0x%"PRIx64);
+ pv(di, di_goal_data, "%"PRIu64, "0x%"PRIx64);
pv(di, di_flags, "0x%.8X", NULL);
- pv(di, di_payload_format, "%u", "0x%x");
- pv(di, di_height, "%u", "0x%x");
-
- pv(di, di_depth, "%u", "0x%x");
- pv(di, di_entries, "%u", "0x%x");
-
- pv(di, di_eattr, "%llu", "0x%llx");
+ pv(di, di_payload_format, "%"PRIu32, "0x%"PRIx32);
+ pv(di, di_height, "%"PRIu16, "0x%"PRIx16);
+ pv(di, di_depth, "%"PRIu16, "0x%"PRIx16);
+ pv(di, di_entries, "%"PRIu32, "0x%"PRIx32);
+ pv(di, di_eattr, "%"PRIu64, "0x%"PRIx64);
+ pv(di, di_atime_nsec, "%"PRIu32, "0x%"PRIx32);
+ pv(di, di_mtime_nsec, "%"PRIu32, "0x%"PRIx32);
+ pv(di, di_ctime_nsec, "%"PRIu32, "0x%"PRIx32);
}
void gfs2_dirent_in(struct gfs2_dirent *de, char *buf)
@@ -415,17 +381,9 @@ void gfs2_dirent_in(struct gfs2_dirent *de, char *buf)
CPIN_16(de, str, de_rec_len);
CPIN_16(de, str, de_name_len);
CPIN_16(de, str, de_type);
-#ifdef GFS2_HAS_DE_RAHEAD
CPIN_16(de, str, de_rahead);
-#ifdef GFS2_HAS_DE_COOKIE
CPIN_32(de, str, de_cookie);
CPIN_08(de, str, pad3, 8);
-#else
- CPIN_08(de, str, pad2, 12);
-#endif /* GFS2_HAS_DE_COOKIE */
-#else
- CPIN_08(de, str, __pad, 14);
-#endif /* GFS2_HAS_DE_RAHEAD */
}
void gfs2_dirent_out(struct gfs2_dirent *de, char *buf)
@@ -437,17 +395,9 @@ void gfs2_dirent_out(struct gfs2_dirent *de, char *buf)
CPOUT_16(de, str, de_rec_len);
CPOUT_16(de, str, de_name_len);
CPOUT_16(de, str, de_type);
-#ifdef GFS2_HAS_DE_RAHEAD
CPOUT_16(de, str, de_rahead);
-#ifdef GFS2_HAS_DE_COOKIE
CPOUT_32(de, str, de_cookie);
CPOUT_08(de, str, pad3, 8);
-#else
- CPOUT_08(de, str, pad2, 12);
-#endif /* GFS2_HAS_DE_COOKIE */
-#else
- CPOUT_08(de, str, __pad, 14);
-#endif /* GFS2_HAS_DE_RAHEAD */
}
void gfs2_leaf_in(struct gfs2_leaf *lf, char *buf)
@@ -459,15 +409,11 @@ void gfs2_leaf_in(struct gfs2_leaf *lf, char *buf)
CPIN_16(lf, str, lf_entries);
CPIN_32(lf, str, lf_dirent_format);
CPIN_64(lf, str, lf_next);
-#ifdef GFS2_HAS_LEAF_HINTS
CPIN_64(lf, str, lf_inode);
CPIN_32(lf, str, lf_dist);
CPIN_32(lf, str, lf_nsec);
CPIN_64(lf, str, lf_sec);
CPIN_08(lf, str, lf_reserved2, 40);
-#else
- CPIN_08(lf, str, lf_reserved, 32);
-#endif
}
void gfs2_leaf_out(struct gfs2_leaf *lf, char *buf)
@@ -479,30 +425,24 @@ void gfs2_leaf_out(struct gfs2_leaf *lf, char *buf)
CPOUT_16(lf, str, lf_entries);
CPOUT_32(lf, str, lf_dirent_format);
CPOUT_64(lf, str, lf_next);
-#ifdef GFS2_HAS_LEAF_HINTS
CPOUT_64(lf, str, lf_inode);
CPOUT_32(lf, str, lf_dist);
CPOUT_32(lf, str, lf_nsec);
CPOUT_64(lf, str, lf_sec);
CPOUT_08(lf, str, lf_reserved2, 40);
-#else
- CPOUT_08(lf, str, lf_reserved, 64);
-#endif
}
void gfs2_leaf_print(const struct gfs2_leaf *lf)
{
gfs2_meta_header_print(&lf->lf_header);
- pv(lf, lf_depth, "%u", "0x%x");
- pv(lf, lf_entries, "%u", "0x%x");
- pv(lf, lf_dirent_format, "%u", "0x%x");
- pv(lf, lf_next, "%llu", "0x%llx");
-#ifdef GFS2_HAS_LEAF_HINTS
- pv(lf, lf_inode, "%llu", "0x%llx");
- pv(lf, lf_dist, "%u", "0x%x");
- pv(lf, lf_nsec, "%u", "0x%x");
- pv(lf, lf_sec, "%llu", "0x%llx");
-#endif
+ pv(lf, lf_depth, "%"PRIu16, "0x%"PRIx16);
+ pv(lf, lf_entries, "%"PRIu16, "0x%"PRIx16);
+ pv(lf, lf_dirent_format, "%"PRIu32, "0x%"PRIx32);
+ pv(lf, lf_next, "%"PRIu64, "0x%"PRIx64);
+ pv(lf, lf_inode, "%"PRIu64, "0x%"PRIx64);
+ pv(lf, lf_dist, "%"PRIu32, "0x%"PRIx32);
+ pv(lf, lf_nsec, "%"PRIu32, "0x%"PRIx32);
+ pv(lf, lf_sec, "%"PRIu64, "0x%"PRIx64);
}
void gfs2_ea_header_in(struct gfs2_ea_header *ea, char *buf)
@@ -521,19 +461,19 @@ void gfs2_ea_header_print(const struct gfs2_ea_header *ea, char *name)
{
char buf[GFS2_EA_MAX_NAME_LEN + 1];
- pv(ea, ea_rec_len, "%u", "0x%x");
- pv(ea, ea_data_len, "%u", "0x%x");
- pv(ea, ea_name_len, "%u", "0x%x");
- pv(ea, ea_type, "%u", "0x%x");
- pv(ea, ea_flags, "%u", "0x%x");
- pv(ea, ea_num_ptrs, "%u", "0x%x");
+ pv(ea, ea_rec_len, "%"PRIu32, "0x%"PRIx32);
+ pv(ea, ea_data_len, "%"PRIu32, "0x%"PRIx32);
+ pv(ea, ea_name_len, "%"PRIu8, "0x%"PRIx8);
+ pv(ea, ea_type, "%"PRIu8, "0x%"PRIx8);
+ pv(ea, ea_flags, "%"PRIu8, "0x%"PRIx8);
+ pv(ea, ea_num_ptrs, "%"PRIu8, "0x%"PRIx8);
memset(buf, 0, GFS2_EA_MAX_NAME_LEN + 1);
memcpy(buf, name, ea->ea_name_len);
print_it(" name", "%s", NULL, buf);
}
-void gfs2_log_header_v1_in(struct gfs2_log_header *lh, char *buf)
+void gfs2_log_header_in(struct gfs2_log_header *lh, char *buf)
{
struct gfs2_log_header *str = (struct gfs2_log_header *)buf;
@@ -543,15 +483,6 @@ void gfs2_log_header_v1_in(struct gfs2_log_header *lh, char *buf)
CPIN_32(lh, str, lh_tail);
CPIN_32(lh, str, lh_blkno);
CPIN_32(lh, str, lh_hash);
-}
-
-void gfs2_log_header_in(struct gfs2_log_header *lh, char *buf)
-{
- gfs2_log_header_v1_in(lh, buf);
-#ifdef GFS2_HAS_LH_V2
- {
- struct gfs2_log_header *str = (struct gfs2_log_header *)buf;
-
CPIN_32(lh, str, lh_crc);
CPIN_32(lh, str, lh_nsec);
CPIN_64(lh, str, lh_sec);
@@ -562,11 +493,9 @@ void gfs2_log_header_in(struct gfs2_log_header *lh, char *buf)
CPIN_64(lh, str, lh_local_total);
CPIN_64(lh, str, lh_local_free);
CPIN_64(lh, str, lh_local_dinodes);
- }
-#endif
}
-void gfs2_log_header_v1_out(struct gfs2_log_header *lh, char *buf)
+void gfs2_log_header_out(struct gfs2_log_header *lh, char *buf)
{
struct gfs2_log_header *str = (struct gfs2_log_header *)buf;
@@ -576,15 +505,6 @@ void gfs2_log_header_v1_out(struct gfs2_log_header *lh, char *buf)
CPOUT_32(lh, str, lh_tail);
CPOUT_32(lh, str, lh_blkno);
CPOUT_32(lh, str, lh_hash);
-}
-
-void gfs2_log_header_out(struct gfs2_log_header *lh, char *buf)
-{
- gfs2_log_header_v1_out(lh, buf);
-#ifdef GFS2_HAS_LH_V2
- {
- struct gfs2_log_header *str = (struct gfs2_log_header *)buf;
-
CPOUT_32(lh, str, lh_crc);
CPOUT_32(lh, str, lh_nsec);
CPOUT_64(lh, str, lh_sec);
@@ -595,35 +515,26 @@ void gfs2_log_header_out(struct gfs2_log_header *lh, char *buf)
CPOUT_64(lh, str, lh_local_total);
CPOUT_64(lh, str, lh_local_free);
CPOUT_64(lh, str, lh_local_dinodes);
- }
-#endif
}
-void gfs2_log_header_v1_print(const struct gfs2_log_header *lh)
+void gfs2_log_header_print(const struct gfs2_log_header *lh)
{
gfs2_meta_header_print(&lh->lh_header);
- pv(lh, lh_sequence, "%llu", "0x%llx");
+ pv(lh, lh_sequence, "%"PRIu64, "0x%"PRIx64);
pv(lh, lh_flags, "0x%.8X", NULL);
- pv(lh, lh_tail, "%u", "0x%x");
- pv(lh, lh_blkno, "%u", "0x%x");
+ pv(lh, lh_tail, "%"PRIu32, "0x%"PRIx32);
+ pv(lh, lh_blkno, "%"PRIu32, "0x%"PRIx32);
pv(lh, lh_hash, "0x%.8X", NULL);
-}
-
-void gfs2_log_header_print(const struct gfs2_log_header *lh)
-{
- gfs2_log_header_v1_print(lh);
-#ifdef GFS2_HAS_LH_V2
pv(lh, lh_crc, "0x%.8X", NULL);
- pv(lh, lh_nsec, "%u", "0x%x");
- pv(lh, lh_sec, "%llu", "0x%llx");
- pv(lh, lh_addr, "%llu", "0x%llx");
- pv(lh, lh_jinode, "%llu", "0x%llx");
- pv(lh, lh_statfs_addr, "%llu", "0x%llx");
- pv(lh, lh_quota_addr, "%llu", "0x%llx");
- pv(lh, lh_local_total, "%lld", "0x%llx");
- pv(lh, lh_local_free, "%lld", "0x%llx");
- pv(lh, lh_local_dinodes, "%lld", "0x%llx");
-#endif
+ pv(lh, lh_nsec, "%"PRIu32, "0x%"PRIx32);
+ pv(lh, lh_sec, "%"PRIu64, "0x%"PRIx64);
+ pv(lh, lh_addr, "%"PRIu64, "0x%"PRIx64);
+ pv(lh, lh_jinode, "%"PRIu64, "0x%"PRIx64);
+ pv(lh, lh_statfs_addr, "%"PRIu64, "0x%"PRIx64);
+ pv(lh, lh_quota_addr, "%"PRIu64, "0x%"PRIx64);
+ pv(lh, lh_local_total, "%"PRId64, "0x%"PRIx64);
+ pv(lh, lh_local_free, "%"PRId64, "0x%"PRIx64);
+ pv(lh, lh_local_dinodes, "%"PRId64, "0x%"PRIx64);
}
void gfs2_log_descriptor_in(struct gfs2_log_descriptor *ld, char *buf)
@@ -655,10 +566,10 @@ void gfs2_log_descriptor_out(struct gfs2_log_descriptor *ld, char *buf)
void gfs2_log_descriptor_print(const struct gfs2_log_descriptor *ld)
{
gfs2_meta_header_print(&ld->ld_header);
- pv(ld, ld_type, "%u", "0x%x");
- pv(ld, ld_length, "%u", "0x%x");
- pv(ld, ld_data1, "%u", "0x%x");
- pv(ld, ld_data2, "%u", "0x%x");
+ pv(ld, ld_type, "%"PRIu32, "0x%"PRIx32);
+ pv(ld, ld_length, "%"PRIu32, "0x%"PRIx32);
+ pv(ld, ld_data1, "%"PRIu32, "0x%"PRIx32);
+ pv(ld, ld_data2, "%"PRIu32, "0x%"PRIx32);
}
void gfs2_statfs_change_in(struct gfs2_statfs_change *sc, char *buf)
@@ -681,9 +592,9 @@ void gfs2_statfs_change_out(struct gfs2_statfs_change *sc, char *buf)
void gfs2_statfs_change_print(const struct gfs2_statfs_change *sc)
{
- pv(sc, sc_total, "%lld", "0x%llx");
- pv(sc, sc_free, "%lld", "0x%llx");
- pv(sc, sc_dinodes, "%lld", "0x%llx");
+ pv(sc, sc_total, "%"PRId64, "0x%"PRIx64);
+ pv(sc, sc_free, "%"PRId64, "0x%"PRIx64);
+ pv(sc, sc_dinodes, "%"PRId64, "0x%"PRIx64);
}
void gfs2_quota_change_in(struct gfs2_quota_change *qc, char *buf)
@@ -708,8 +619,8 @@ void gfs2_quota_change_out(struct gfs2_quota_change *qc, char *buf)
void gfs2_quota_change_print(const struct gfs2_quota_change *qc)
{
- pv(qc, qc_change, "%lld", "0x%llx");
+ pv(qc, qc_change, "%"PRId64, "0x%"PRIx64);
pv(qc, qc_flags, "0x%.8X", NULL);
- pv(qc, qc_id, "%u", "0x%x");
+ pv(qc, qc_id, "%"PRIu32, "0x%"PRIx32);
}
diff --git a/gfs2/libgfs2/recovery.c b/gfs2/libgfs2/recovery.c
index 06f81116..bc446cfe 100644
--- a/gfs2/libgfs2/recovery.c
+++ b/gfs2/libgfs2/recovery.c
@@ -72,9 +72,7 @@ int get_log_header(struct gfs2_inode *ip, unsigned int blk,
crc = lgfs2_log_header_crc(bh->b_data, ip->i_sbd->bsize);
gfs2_log_header_in(&lh, bh->b_data);
brelse(bh);
-#ifdef GFS2_HAS_LH_V2
lh_crc = lh.lh_crc;
-#endif
if (error || lh.lh_blkno != blk || lh.lh_hash != hash)
return 1;
/* Don't check the crc if it's zero, as it is in pre-v2 log headers */
diff --git a/gfs2/libgfs2/rgrp.c b/gfs2/libgfs2/rgrp.c
index 3cdaccae..e1748a4c 100644
--- a/gfs2/libgfs2/rgrp.c
+++ b/gfs2/libgfs2/rgrp.c
@@ -164,7 +164,6 @@ void lgfs2_rgrp_bitbuf_free(lgfs2_rgrp_t rg)
int lgfs2_rgrp_crc_check(char *buf)
{
int ret = 0;
-#ifdef GFS2_HAS_RG_RI_FIELDS
struct gfs2_rgrp *rg = (struct gfs2_rgrp *)buf;
uint32_t crc = rg->rg_crc;
@@ -175,7 +174,6 @@ int lgfs2_rgrp_crc_check(char *buf)
if (be32_to_cpu(crc) != gfs2_disk_hash(buf, sizeof(struct gfs2_rgrp)))
ret = 1;
rg->rg_crc = crc;
-#endif
return ret;
}
@@ -184,14 +182,12 @@ int lgfs2_rgrp_crc_check(char *buf)
*/
void lgfs2_rgrp_crc_set(char *buf)
{
-#ifdef GFS2_HAS_RG_RI_FIELDS
struct gfs2_rgrp *rg = (struct gfs2_rgrp *)buf;
uint32_t crc;
rg->rg_crc = 0;
crc = gfs2_disk_hash(buf, sizeof(struct gfs2_rgrp));
rg->rg_crc = cpu_to_be32(crc);
-#endif
}
/**
@@ -666,15 +662,11 @@ lgfs2_rgrp_t lgfs2_rgrps_append(lgfs2_rgrps_t rgs, struct gfs2_rindex *entry, ui
rg->rg.rg_header.mh_type = GFS2_METATYPE_RG;
rg->rg.rg_header.mh_format = GFS2_FORMAT_RG;
rg->rg.rg_free = rg->ri.ri_data;
-#ifdef GFS2_HAS_RG_SKIP
rg->rg.rg_skip = rg_skip;
-#endif
-#ifdef GFS2_HAS_RG_RI_FIELDS
rg->rg.rg_data0 = rg->ri.ri_data0;
rg->rg.rg_data = rg->ri.ri_data;
rg->rg.rg_bitbytes = rg->ri.ri_bitbytes;
rg->rg.rg_crc = 0;
-#endif
compute_bitmaps(rg, rgs->sdp->bsize);
rg->rgrps = rgs;
return rg;
diff --git a/gfs2/libgfs2/structures.c b/gfs2/libgfs2/structures.c
index c84701d4..f05e7f2d 100644
--- a/gfs2/libgfs2/structures.c
+++ b/gfs2/libgfs2/structures.c
@@ -10,17 +10,13 @@
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
-#include <linux/types.h>
#include <sys/time.h>
+#include <uuid.h>
#include "libgfs2.h"
#include "config.h"
#include "crc32c.h"
-#ifdef GFS2_HAS_UUID
-#include <uuid.h>
-#endif
-
int build_master(struct gfs2_sbd *sdp)
{
struct gfs2_inum inum;
@@ -63,9 +59,7 @@ void lgfs2_sb_init(struct gfs2_sb *sb, unsigned bsize)
sb->sb_multihost_format = GFS2_FORMAT_MULTI;
sb->sb_bsize = bsize;
sb->sb_bsize_shift = ffs(bsize) - 1;
-#ifdef GFS2_HAS_UUID
uuid_generate(sb->sb_uuid);
-#endif
}
int lgfs2_sb_write(const struct gfs2_sb *sb, int fd, const unsigned bsize)
@@ -113,15 +107,11 @@ uint32_t lgfs2_log_header_hash(char *buf)
uint32_t lgfs2_log_header_crc(char *buf, unsigned bsize)
{
-#ifdef GFS2_HAS_LH_V2
/* lh_crc CRCs the rest of the block starting after lh_crc */
const off_t v1_end = offsetof(struct gfs2_log_header, lh_hash) + 4;
const unsigned char *lb = (const unsigned char *)buf;
return crc32c(~0, lb + v1_end + 4, bsize - v1_end - 4);
-#else
- return 0;
-#endif
}
/**
@@ -141,7 +131,6 @@ int lgfs2_write_journal_data(struct gfs2_inode *ip)
.lh_tail = 0,
.lh_blkno = 0,
.lh_hash = 0,
-#ifdef GFS2_HAS_LH_V2
.lh_flags = GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_USERSPACE,
.lh_crc = 0,
.lh_nsec = 0,
@@ -152,9 +141,6 @@ int lgfs2_write_journal_data(struct gfs2_inode *ip)
.lh_local_total = 0,
.lh_local_free = 0,
.lh_local_dinodes = 0,
-#else
- .lh_flags = GFS2_LOG_HEAD_UNMOUNT,
-#endif
};
struct gfs2_buffer_head *bh;
struct gfs2_sbd *sdp = ip->i_sbd;
@@ -175,10 +161,8 @@ int lgfs2_write_journal_data(struct gfs2_inode *ip)
gfs2_log_header_out(&lh, bh->b_data);
buflh->lh_hash = cpu_to_be32(lgfs2_log_header_hash(bh->b_data));
-#ifdef GFS2_HAS_LH_V2
buflh->lh_addr = cpu_to_be64(bh->b_blocknr);
buflh->lh_crc = cpu_to_be32(lgfs2_log_header_crc(bh->b_data, sdp->bsize));
-#endif
if (bwrite(bh)) {
free(bh);
@@ -212,10 +196,8 @@ int write_journal(struct gfs2_inode *jnl, unsigned bsize, unsigned int blocks)
lh.lh_header.mh_type = GFS2_METATYPE_LH;
lh.lh_header.mh_format = GFS2_FORMAT_LH;
lh.lh_flags = GFS2_LOG_HEAD_UNMOUNT;
-#ifdef GFS2_HAS_LH_V2
lh.lh_flags |= GFS2_LOG_HEAD_USERSPACE;
lh.lh_jinode = jnl->i_di.di_num.no_addr;
-#endif
for (x = 0; x < blocks; x++) {
struct gfs2_buffer_head *bh = get_file_buf(jnl, x, TRUE);
if (!bh)
@@ -235,11 +217,9 @@ int write_journal(struct gfs2_inode *jnl, unsigned bsize, unsigned int blocks)
gfs2_log_header_out(&lh, bh->b_data);
hash = lgfs2_log_header_hash(bh->b_data);
((struct gfs2_log_header *)bh->b_data)->lh_hash = cpu_to_be32(hash);
-#ifdef GFS2_HAS_LH_V2
((struct gfs2_log_header *)bh->b_data)->lh_addr = cpu_to_be64(bh->b_blocknr);
hash = lgfs2_log_header_crc(bh->b_data, bsize);
((struct gfs2_log_header *)bh->b_data)->lh_crc = cpu_to_be32(hash);
-#endif
bmodified(bh);
brelse(bh);
diff --git a/gfs2/mkfs/gfs2_mkfs.h b/gfs2/mkfs/gfs2_mkfs.h
index 75f70e6a..5f358354 100644
--- a/gfs2/mkfs/gfs2_mkfs.h
+++ b/gfs2/mkfs/gfs2_mkfs.h
@@ -2,7 +2,7 @@
#define __GFS2_MKFS_DOT_H__
#include <stdarg.h>
-#include <linux/gfs2_ondisk.h>
+#include <gfs2_ondisk.h>
#include "osi_list.h"
#include "copyright.cf"
diff --git a/gfs2/mkfs/main_grow.c b/gfs2/mkfs/main_grow.c
index ad80a8d9..7e56d2cd 100644
--- a/gfs2/mkfs/main_grow.c
+++ b/gfs2/mkfs/main_grow.c
@@ -15,7 +15,6 @@
#include <time.h>
#include <errno.h>
#include <stdarg.h>
-#include <linux/types.h>
#include <blkid.h>
#include <libintl.h>
#include <locale.h>
diff --git a/gfs2/mkfs/main_jadd.c b/gfs2/mkfs/main_jadd.c
index efe91e30..2a64f390 100644
--- a/gfs2/mkfs/main_jadd.c
+++ b/gfs2/mkfs/main_jadd.c
@@ -20,7 +20,6 @@
#include <locale.h>
#define _(String) gettext(String)
-#include <linux/types.h>
#include <linux/fiemap.h>
#include <linux/fs.h>
#include "libgfs2.h"
@@ -425,7 +424,6 @@ close:
opts->orig_journals = existing_journals;
}
-#ifdef GFS2_HAS_LH_V2
static uint64_t find_block_address(int fd, off_t offset, unsigned bsize)
{
struct {
@@ -446,7 +444,6 @@ static uint64_t find_block_address(int fd, off_t offset, unsigned bsize)
}
return fme.fe.fe_physical / bsize;
}
-#endif
static void add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
{
@@ -482,10 +479,8 @@ static void add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
lh.lh_header.mh_type = GFS2_METATYPE_LH;
lh.lh_header.mh_format = GFS2_FORMAT_LH;
lh.lh_flags = GFS2_LOG_HEAD_UNMOUNT;
-#ifdef GFS2_HAS_LH_V2
lh.lh_flags |= GFS2_LOG_HEAD_USERSPACE;
lh.lh_jinode = addr;
-#endif
for (x=0; x<blocks; x++) {
uint32_t hash;
@@ -494,12 +489,10 @@ static void add_j(struct gfs2_sbd *sdp, struct jadd_opts *opts)
gfs2_log_header_out(&lh, buf);
hash = lgfs2_log_header_hash(buf);
((struct gfs2_log_header *)buf)->lh_hash = cpu_to_be32(hash);
-#ifdef GFS2_HAS_LH_V2
((struct gfs2_log_header *)buf)->lh_addr = cpu_to_be64(
find_block_address(fd, off, sdp->bsize));
hash = lgfs2_log_header_crc(buf, sdp->bsize);
((struct gfs2_log_header *)buf)->lh_crc = cpu_to_be32(hash);
-#endif
if (write(fd, buf, sdp->bsize) != sdp->bsize) {
perror("add_j");
exit(EXIT_FAILURE);
diff --git a/gfs2/mkfs/main_mkfs.c b/gfs2/mkfs/main_mkfs.c
index 7aeae695..d65aafd7 100644
--- a/gfs2/mkfs/main_mkfs.c
+++ b/gfs2/mkfs/main_mkfs.c
@@ -22,18 +22,14 @@
#include <limits.h>
#include <blkid.h>
#include <locale.h>
+#include <uuid.h>
#define _(String) gettext(String)
-#include <linux/types.h>
#include "libgfs2.h"
#include "gfs2_mkfs.h"
#include "progress.h"
-#ifdef GFS2_HAS_UUID
-#include <uuid.h>
-#endif
-
static void print_usage(const char *prog_name)
{
int i;
@@ -566,6 +562,8 @@ static void opts_check(struct mkfs_opts *opts)
static void print_results(struct gfs2_sb *sb, struct mkfs_opts *opts, uint64_t rgrps, uint64_t fssize)
{
+ char readable_uuid[36+1];
+
printf("%-27s%s\n", _("Device:"), opts->dev.path);
printf("%-27s%u\n", _("Block size:"), sb->sb_bsize);
printf("%-27s%.2f %s (%"PRIu64" %s)\n", _("Device size:"),
@@ -579,15 +577,9 @@ static void print_results(struct gfs2_sb *sb, struct mkfs_opts *opts, uint64_t r
printf("%-27s%"PRIu64"\n", _("Resource groups:"), rgrps);
printf("%-27s\"%s\"\n", _("Locking protocol:"), opts->lockproto);
printf("%-27s\"%s\"\n", _("Lock table:"), opts->locktable);
-#ifdef GFS2_HAS_UUID
- {
- char readable_uuid[36+1];
-
uuid_unparse(sb->sb_uuid, readable_uuid);
/* Translators: "UUID" = universally unique identifier. */
printf("%-27s%s\n", _("UUID:"), readable_uuid);
- }
-#endif
}
static void warn_of_destruction(const char *path)
diff --git a/gfs2/tune/super.c b/gfs2/tune/super.c
index f4b7d85b..73af0bb3 100644
--- a/gfs2/tune/super.c
+++ b/gfs2/tune/super.c
@@ -11,12 +11,9 @@
#include <libintl.h>
#define _(String) gettext(String)
#include <linux_endian.h>
-#include <linux/gfs2_ondisk.h>
-#include "tunegfs2.h"
-
-#ifdef GFS2_HAS_UUID
+#include <gfs2_ondisk.h>
#include <uuid.h>
-#endif
+#include "tunegfs2.h"
int read_super(struct tunegfs2 *tfs)
{
@@ -54,15 +51,11 @@ static int is_gfs2(const struct tunegfs2 *tfs)
int print_super(const struct tunegfs2 *tfs)
{
- printf(_("File system volume name: %s\n"), tfs->sb->sb_locktable);
-#ifdef GFS2_HAS_UUID
- {
char readable_uuid[36+1];
+ printf(_("File system volume name: %s\n"), tfs->sb->sb_locktable);
uuid_unparse(tfs->sb->sb_uuid, readable_uuid);
printf(_("File system UUID: %s\n"), readable_uuid);
- }
-#endif
printf( _("File system magic number: 0x%X\n"), be32_to_cpu(tfs->sb->sb_header.mh_magic));
printf(_("Block size: %d\n"), be32_to_cpu(tfs->sb->sb_bsize));
printf(_("Block shift: %d\n"), be32_to_cpu(tfs->sb->sb_bsize_shift));
@@ -88,7 +81,6 @@ int write_super(const struct tunegfs2 *tfs)
int change_uuid(struct tunegfs2 *tfs, const char *str)
{
-#ifdef GFS2_HAS_UUID
uuid_t uuid;
int status;
@@ -96,10 +88,6 @@ int change_uuid(struct tunegfs2 *tfs, const char *str)
if (status == 0)
uuid_copy(tfs->sb->sb_uuid, uuid);
return status;
-#else
- fprintf(stderr, _("UUID support unavailable in this build\n"));
- return 1;
-#endif
}
int change_lockproto(struct tunegfs2 *tfs, const char *lockproto)
--
2.20.1
More information about the Cluster-devel
mailing list