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 <anpr...@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