diff options
Diffstat (limited to 'meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch')
| -rw-r--r-- | meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch | 3800 |
1 files changed, 3800 insertions, 0 deletions
diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch b/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch new file mode 100644 index 0000000000..5e08f0d840 --- /dev/null +++ b/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch @@ -0,0 +1,3800 @@ +From 14f8b6810bd240cc58131483790a099fcf56c073 Mon Sep 17 00:00:00 2001 +From: "Darrick J. Wong" <darrick.wong@oracle.com> +Date: Fri, 4 Aug 2017 16:33:51 -0500 +Subject: [PATCH] xfsprogs: remove double-underscore integer types + +This is a purely mechanical patch that removes the private +__{u,}int{8,16,32,64}_t typedefs in favor of using the system +{u,}int{8,16,32,64}_t typedefs. This is the sed script used to perform +the transformation and fix the resulting whitespace and indentation +errors: + +s/typedef\t__uint8_t/typedef __uint8_t\t/g +s/typedef\t__uint/typedef __uint/g +s/typedef\t__int\([0-9]*\)_t/typedef int\1_t\t/g +s/__uint8_t\t/__uint8_t\t\t/g +s/__uint/uint/g +s/__int\([0-9]*\)_t\t/__int\1_t\t\t/g +s/__int/int/g +/^typedef.*int[0-9]*_t;$/d + +Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com> +Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com> +[sandeen: fix whitespace incidentals] +Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com> +Signed-off-by: Eric Sandeen <sandeen@sandeen.net> +--- + copy/xfs_copy.c | 14 ++++----- + copy/xfs_copy.h | 2 +- + db/attr.c | 8 ++--- + db/attrshort.c | 4 +-- + db/bit.c | 4 +-- + db/bit.h | 2 +- + db/block.c | 8 ++--- + db/check.c | 18 +++++------ + db/convert.c | 28 ++++++++--------- + db/faddr.c | 14 ++++----- + db/field.c | 44 +++++++++++++-------------- + db/fprint.c | 8 ++--- + db/frag.c | 8 ++--- + db/inode.c | 34 ++++++++++----------- + db/io.c | 2 +- + db/io.h | 6 ++-- + db/metadump.c | 12 ++++---- + db/sb.c | 6 ++-- + fsr/xfs_fsr.c | 2 +- + include/darwin.h | 18 +++++------ + include/freebsd.h | 6 ++-- + include/gnukfreebsd.h | 6 ++-- + include/libxcmd.h | 6 ++-- + include/linux.h | 8 ++--- + include/xfs_arch.h | 22 +++++++------- + include/xfs_inode.h | 4 +-- + include/xfs_log_recover.h | 2 +- + include/xfs_metadump.h | 4 +-- + include/xfs_mount.h | 22 +++++++------- + libhandle/handle.c | 2 +- + libhandle/jdm.c | 2 +- + libxcmd/topology.c | 14 ++++----- + libxfs/darwin.c | 2 +- + libxfs/freebsd.c | 2 +- + libxfs/init.c | 2 +- + libxfs/irix.c | 2 +- + libxfs/libxfs_priv.h | 4 +-- + libxfs/linux.c | 2 +- + libxfs/logitem.c | 2 +- + libxfs/radix-tree.c | 8 ++--- + libxfs/rdwr.c | 6 ++-- + libxfs/util.c | 8 ++--- + logprint/log_misc.c | 6 ++-- + mdrestore/xfs_mdrestore.c | 2 +- + mkfs/proto.c | 2 +- + mkfs/xfs_mkfs.c | 76 +++++++++++++++++++++++------------------------ + quota/edit.c | 64 +++++++++++++++++++-------------------- + quota/free.c | 44 +++++++++++++-------------- + quota/quot.c | 24 +++++++-------- + quota/quota.c | 4 +-- + quota/quota.h | 12 ++++---- + quota/report.c | 4 +-- + quota/state.c | 2 +- + quota/util.c | 66 ++++++++++++++++++++-------------------- + repair/README | 2 +- + repair/agheader.h | 14 ++++----- + repair/attr_repair.h | 26 ++++++++-------- + repair/avl64.c | 38 ++++++++++++------------ + repair/avl64.h | 18 +++++------ + repair/dinode.c | 38 ++++++++++++------------ + repair/dinode.h | 4 +-- + repair/dir2.c | 2 +- + repair/globals.h | 18 +++++------ + repair/incore.c | 10 +++---- + repair/incore.h | 46 ++++++++++++++-------------- + repair/incore_ext.c | 6 ++-- + repair/incore_ino.c | 72 ++++++++++++++++++++++---------------------- + repair/phase2.c | 2 +- + repair/phase3.c | 6 ++-- + repair/phase4.c | 4 +-- + repair/phase5.c | 28 ++++++++--------- + repair/phase6.c | 16 +++++----- + repair/phase7.c | 6 ++-- + repair/progress.c | 30 +++++++++---------- + repair/progress.h | 4 +-- + repair/rmap.c | 18 +++++------ + repair/rmap.h | 2 +- + repair/sb.c | 24 +++++++-------- + repair/scan.c | 50 +++++++++++++++---------------- + repair/scan.h | 12 ++++---- + 80 files changed, 590 insertions(+), 590 deletions(-) + +diff --git a/copy/xfs_copy.c b/copy/xfs_copy.c +index a7da824f..33e05dfd 100644 +--- a/copy/xfs_copy.c ++++ b/copy/xfs_copy.c +@@ -43,7 +43,7 @@ unsigned int source_sectorsize; /* source disk sectorsize */ + + xfs_agblock_t first_agbno; + +-__uint64_t barcount[11]; ++uint64_t barcount[11]; + + unsigned int num_targets; + target_control *target; +@@ -313,7 +313,7 @@ usage(void) + } + + void +-init_bar(__uint64_t source_blocks) ++init_bar(uint64_t source_blocks) + { + int i; + +@@ -322,7 +322,7 @@ init_bar(__uint64_t source_blocks) + } + + int +-bump_bar(int tenths, __uint64_t numblocks) ++bump_bar(int tenths, uint64_t numblocks) + { + static char *bar[11] = { + " 0% ", +@@ -534,8 +534,8 @@ main(int argc, char **argv) + xfs_off_t pos; + size_t length; + int c; +- __uint64_t size, sizeb; +- __uint64_t numblocks = 0; ++ uint64_t size, sizeb; ++ uint64_t numblocks = 0; + int wblocks = 0; + int num_threads = 0; + struct dioattr d; +@@ -951,8 +951,8 @@ main(int argc, char **argv) + num_ags = mp->m_sb.sb_agcount; + + init_bar(mp->m_sb.sb_blocksize / BBSIZE +- * ((__uint64_t)mp->m_sb.sb_dblocks +- - (__uint64_t)mp->m_sb.sb_fdblocks + 10 * num_ags)); ++ * ((uint64_t)mp->m_sb.sb_dblocks ++ - (uint64_t)mp->m_sb.sb_fdblocks + 10 * num_ags)); + + kids = num_targets; + +diff --git a/copy/xfs_copy.h b/copy/xfs_copy.h +index 27370688..53c6e42c 100644 +--- a/copy/xfs_copy.h ++++ b/copy/xfs_copy.h +@@ -76,7 +76,7 @@ typedef struct { + + typedef int thread_id; + typedef int tm_index; /* index into thread mask array */ +-typedef __uint32_t thread_mask; /* a thread mask */ ++typedef uint32_t thread_mask; /* a thread mask */ + + typedef struct { + char *name; +diff --git a/db/attr.c b/db/attr.c +index 31536a8b..23ffcd5f 100644 +--- a/db/attr.c ++++ b/db/attr.c +@@ -77,16 +77,16 @@ const field_t attr_leaf_entry_flds[] = { + { "nameidx", FLDT_UINT16D, OI(LEOFF(nameidx)), C1, 0, TYP_NONE }, + { "flags", FLDT_UINT8X, OI(LEOFF(flags)), C1, FLD_SKIPALL, TYP_NONE }, + { "incomplete", FLDT_UINT1, +- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_INCOMPLETE_BIT - 1), C1, ++ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_INCOMPLETE_BIT - 1), C1, + 0, TYP_NONE }, + { "root", FLDT_UINT1, +- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0, ++ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0, + TYP_NONE }, + { "secure", FLDT_UINT1, +- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0, ++ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0, + TYP_NONE }, + { "local", FLDT_UINT1, +- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_LOCAL_BIT - 1), C1, 0, ++ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_LOCAL_BIT - 1), C1, 0, + TYP_NONE }, + { "pad2", FLDT_UINT8X, OI(LEOFF(pad2)), C1, FLD_SKIPALL, TYP_NONE }, + { NULL } +diff --git a/db/attrshort.c b/db/attrshort.c +index d82559cc..2ef358f5 100644 +--- a/db/attrshort.c ++++ b/db/attrshort.c +@@ -51,10 +51,10 @@ const field_t attr_sf_entry_flds[] = { + { "valuelen", FLDT_UINT8D, OI(EOFF(valuelen)), C1, 0, TYP_NONE }, + { "flags", FLDT_UINT8X, OI(EOFF(flags)), C1, FLD_SKIPALL, TYP_NONE }, + { "root", FLDT_UINT1, +- OI(EOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0, ++ OI(EOFF(flags) + bitsz(uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0, + TYP_NONE }, + { "secure", FLDT_UINT1, +- OI(EOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0, ++ OI(EOFF(flags) + bitsz(uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0, + TYP_NONE }, + { "name", FLDT_CHARNS, OI(EOFF(nameval)), attr_sf_entry_name_count, + FLD_COUNT, TYP_NONE }, +diff --git a/db/bit.c b/db/bit.c +index 24872bf7..f5ebf681 100644 +--- a/db/bit.c ++++ b/db/bit.c +@@ -60,7 +60,7 @@ setbit( + } + } + +-__int64_t ++int64_t + getbitval( + void *obj, + int bitoff, +@@ -70,7 +70,7 @@ getbitval( + int bit; + int i; + char *p; +- __int64_t rval; ++ int64_t rval; + int signext; + int z1, z2, z3, z4; + +diff --git a/db/bit.h b/db/bit.h +index 80ba24c4..9fd71f4b 100644 +--- a/db/bit.h ++++ b/db/bit.h +@@ -25,5 +25,5 @@ + #define BVUNSIGNED 0 + #define BVSIGNED 1 + +-extern __int64_t getbitval(void *obj, int bitoff, int nbits, int flags); ++extern int64_t getbitval(void *obj, int bitoff, int nbits, int flags); + extern void setbitval(void *obuf, int bitoff, int nbits, void *ibuf); +diff --git a/db/block.c b/db/block.c +index 4a357ced..5ecd687a 100644 +--- a/db/block.c ++++ b/db/block.c +@@ -98,7 +98,7 @@ ablock_f( + } + dfsbno = bm.startblock + (bno - bm.startoff); + ASSERT(typtab[TYP_ATTR].typnm == TYP_ATTR); +- set_cur(&typtab[TYP_ATTR], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), ++ set_cur(&typtab[TYP_ATTR], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), + blkbb, DB_RING_ADD, NULL); + return 0; + } +@@ -128,14 +128,14 @@ daddr_f( + int argc, + char **argv) + { +- __int64_t d; ++ int64_t d; + char *p; + + if (argc == 1) { + dbprintf(_("current daddr is %lld\n"), iocur_top->off >> BBSHIFT); + return 0; + } +- d = (__int64_t)strtoull(argv[1], &p, 0); ++ d = (int64_t)strtoull(argv[1], &p, 0); + if (*p != '\0' || + d >= mp->m_sb.sb_dblocks << (mp->m_sb.sb_blocklog - BBSHIFT)) { + dbprintf(_("bad daddr %s\n"), argv[1]); +@@ -197,7 +197,7 @@ dblock_f( + ASSERT(typtab[type].typnm == type); + if (nex > 1) + make_bbmap(&bbmap, nex, bmp); +- set_cur(&typtab[type], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), ++ set_cur(&typtab[type], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), + nb * blkbb, DB_RING_ADD, nex > 1 ? &bbmap : NULL); + free(bmp); + return 0; +diff --git a/db/check.c b/db/check.c +index 8e618a23..81ba63a6 100644 +--- a/db/check.c ++++ b/db/check.c +@@ -114,8 +114,8 @@ typedef struct dirhash { + + static xfs_extlen_t agffreeblks; + static xfs_extlen_t agflongest; +-static __uint64_t agf_aggr_freeblks; /* aggregate count over all */ +-static __uint32_t agfbtreeblks; ++static uint64_t agf_aggr_freeblks; /* aggregate count over all */ ++static uint32_t agfbtreeblks; + static int lazycount; + static xfs_agino_t agicount; + static xfs_agino_t agifreecount; +@@ -124,10 +124,10 @@ static int blist_size; + static char **dbmap; /* really dbm_t:8 */ + static dirhash_t **dirhash; + static int error; +-static __uint64_t fdblocks; +-static __uint64_t frextents; +-static __uint64_t icount; +-static __uint64_t ifree; ++static uint64_t fdblocks; ++static uint64_t frextents; ++static uint64_t icount; ++static uint64_t ifree; + static inodata_t ***inodata; + static int inodata_hash_size; + static inodata_t ***inomap; +@@ -1187,7 +1187,7 @@ blocktrash_f( + goto out; + } + for (i = 0; i < count; i++) { +- randb = (xfs_rfsblock_t)((((__int64_t)random() << 32) | ++ randb = (xfs_rfsblock_t)((((int64_t)random() << 32) | + random()) % blocks); + for (bi = 0, agno = 0, done = 0; + !done && agno < mp->m_sb.sb_agcount; +@@ -3032,7 +3032,7 @@ process_leaf_node_dir_v2( + } + if (v) + dbprintf(_("dir inode %lld block %u=%llu\n"), id->ino, +- (__uint32_t)dbno, ++ (uint32_t)dbno, + (xfs_fsblock_t)bmp->startblock); + push_cur(); + if (nex > 1) +@@ -3045,7 +3045,7 @@ process_leaf_node_dir_v2( + if (!sflag || v) + dbprintf(_("can't read block %u for directory " + "inode %lld\n"), +- (__uint32_t)dbno, id->ino); ++ (uint32_t)dbno, id->ino); + error++; + pop_cur(); + dbno += mp->m_dir_geo->fsbcount - 1; +diff --git a/db/convert.c b/db/convert.c +index a337abea..fa4f9623 100644 +--- a/db/convert.c ++++ b/db/convert.c +@@ -24,13 +24,13 @@ + + #define M(A) (1 << CT_ ## A) + #define agblock_to_bytes(x) \ +- ((__uint64_t)(x) << mp->m_sb.sb_blocklog) ++ ((uint64_t)(x) << mp->m_sb.sb_blocklog) + #define agino_to_bytes(x) \ +- ((__uint64_t)(x) << mp->m_sb.sb_inodelog) ++ ((uint64_t)(x) << mp->m_sb.sb_inodelog) + #define agnumber_to_bytes(x) \ +- agblock_to_bytes((__uint64_t)(x) * mp->m_sb.sb_agblocks) ++ agblock_to_bytes((uint64_t)(x) * mp->m_sb.sb_agblocks) + #define daddr_to_bytes(x) \ +- ((__uint64_t)(x) << BBSHIFT) ++ ((uint64_t)(x) << BBSHIFT) + #define fsblock_to_bytes(x) \ + (agnumber_to_bytes(XFS_FSB_TO_AGNO(mp, (x))) + \ + agblock_to_bytes(XFS_FSB_TO_AGBNO(mp, (x)))) +@@ -38,7 +38,7 @@ + (agnumber_to_bytes(XFS_INO_TO_AGNO(mp, (x))) + \ + agino_to_bytes(XFS_INO_TO_AGINO(mp, (x)))) + #define inoidx_to_bytes(x) \ +- ((__uint64_t)(x) << mp->m_sb.sb_inodelog) ++ ((uint64_t)(x) << mp->m_sb.sb_inodelog) + + typedef enum { + CT_NONE = -1, +@@ -68,7 +68,7 @@ typedef union { + xfs_agnumber_t agnumber; + int bboff; + int blkoff; +- __uint64_t byte; ++ uint64_t byte; + xfs_daddr_t daddr; + xfs_fsblock_t fsblock; + xfs_ino_t ino; +@@ -76,7 +76,7 @@ typedef union { + int inooff; + } cval_t; + +-static __uint64_t bytevalue(ctype_t ctype, cval_t *val); ++static uint64_t bytevalue(ctype_t ctype, cval_t *val); + static int convert_f(int argc, char **argv); + static int getvalue(char *s, ctype_t ctype, cval_t *val); + static ctype_t lookupcty(char *ctyname); +@@ -118,7 +118,7 @@ static const cmdinfo_t convert_cmd = + { "convert", NULL, convert_f, 3, 9, 0, "type num [type num]... type", + "convert from one address form to another", NULL }; + +-static __uint64_t ++static uint64_t + bytevalue(ctype_t ctype, cval_t *val) + { + switch (ctype) { +@@ -129,9 +129,9 @@ bytevalue(ctype_t ctype, cval_t *val) + case CT_AGNUMBER: + return agnumber_to_bytes(val->agnumber); + case CT_BBOFF: +- return (__uint64_t)val->bboff; ++ return (uint64_t)val->bboff; + case CT_BLKOFF: +- return (__uint64_t)val->blkoff; ++ return (uint64_t)val->blkoff; + case CT_BYTE: + return val->byte; + case CT_DADDR: +@@ -143,7 +143,7 @@ bytevalue(ctype_t ctype, cval_t *val) + case CT_INOIDX: + return inoidx_to_bytes(val->inoidx); + case CT_INOOFF: +- return (__uint64_t)val->inooff; ++ return (uint64_t)val->inooff; + case CT_NONE: + case NCTS: + break; +@@ -160,7 +160,7 @@ convert_f(int argc, char **argv) + cval_t cvals[NCTS] = {}; + int i; + int mask; +- __uint64_t v; ++ uint64_t v; + ctype_t wtype; + + /* move past the "convert" command */ +@@ -262,7 +262,7 @@ static int + getvalue(char *s, ctype_t ctype, cval_t *val) + { + char *p; +- __uint64_t v; ++ uint64_t v; + + v = strtoull(s, &p, 0); + if (*p != '\0') { +@@ -286,7 +286,7 @@ getvalue(char *s, ctype_t ctype, cval_t *val) + val->blkoff = (int)v; + break; + case CT_BYTE: +- val->byte = (__uint64_t)v; ++ val->byte = (uint64_t)v; + break; + case CT_DADDR: + val->daddr = (xfs_daddr_t)v; +diff --git a/db/faddr.c b/db/faddr.c +index 877200bf..56207648 100644 +--- a/db/faddr.c ++++ b/db/faddr.c +@@ -79,11 +79,11 @@ fa_attrblock( + typnm_t next) + { + bmap_ext_t bm; +- __uint32_t bno; ++ uint32_t bno; + xfs_fsblock_t dfsbno; + int nex; + +- bno = (__uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED); ++ bno = (uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED); + if (bno == 0) { + dbprintf(_("null attribute block number, cannot set new addr\n")); + return; +@@ -96,7 +96,7 @@ fa_attrblock( + } + dfsbno = bm.startblock + (bno - bm.startoff); + ASSERT(typtab[next].typnm == next); +- set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), blkbb, ++ set_cur(&typtab[next], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), blkbb, + DB_RING_ADD, NULL); + } + +@@ -276,11 +276,11 @@ fa_dirblock( + { + bbmap_t bbmap; + bmap_ext_t *bmp; +- __uint32_t bno; ++ uint32_t bno; + xfs_fsblock_t dfsbno; + int nex; + +- bno = (__uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED); ++ bno = (uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED); + if (bno == 0) { + dbprintf(_("null directory block number, cannot set new addr\n")); + return; +@@ -297,7 +297,7 @@ fa_dirblock( + ASSERT(typtab[next].typnm == next); + if (nex > 1) + make_bbmap(&bbmap, nex, bmp); +- set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), ++ set_cur(&typtab[next], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), + XFS_FSB_TO_BB(mp, mp->m_dir_geo->fsbcount), DB_RING_ADD, + nex > 1 ? &bbmap : NULL); + free(bmp); +@@ -317,7 +317,7 @@ fa_drfsbno( + return; + } + ASSERT(typtab[next].typnm == next); +- set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_BB(mp, bno), blkbb, ++ set_cur(&typtab[next], (int64_t)XFS_FSB_TO_BB(mp, bno), blkbb, + DB_RING_ADD, NULL); + } + +diff --git a/db/field.c b/db/field.c +index 865b0b71..f1e5f35e 100644 +--- a/db/field.c ++++ b/db/field.c +@@ -83,7 +83,7 @@ const ftattr_t ftattrtab[] = { + attr_sf_entry_size, FTARG_SIZE, NULL, attr_sf_entry_flds }, + { FLDT_ATTR_SF_HDR, "attr_sf_hdr", NULL, (char *)attr_sf_hdr_flds, + SI(bitsz(struct xfs_attr_sf_hdr)), 0, NULL, attr_sf_hdr_flds }, +- { FLDT_ATTRBLOCK, "attrblock", fp_num, "%u", SI(bitsz(__uint32_t)), 0, ++ { FLDT_ATTRBLOCK, "attrblock", fp_num, "%u", SI(bitsz(uint32_t)), 0, + fa_attrblock, NULL }, + { FLDT_ATTRSHORT, "attrshort", NULL, (char *)attr_shortform_flds, + attrshort_size, FTARG_SIZE, NULL, attr_shortform_flds }, +@@ -199,7 +199,7 @@ const ftattr_t ftattrtab[] = { + SI(bitsz(struct xfs_refcount_rec)), 0, NULL, refcbt_rec_flds }, + + /* CRC field */ +- { FLDT_CRC, "crc", fp_crc, "%#x (%s)", SI(bitsz(__uint32_t)), ++ { FLDT_CRC, "crc", fp_crc, "%#x (%s)", SI(bitsz(uint32_t)), + 0, NULL, NULL }, + + { FLDT_DEV, "dev", fp_num, "%#x", SI(bitsz(xfs_dev_t)), 0, NULL, NULL }, +@@ -214,7 +214,7 @@ const ftattr_t ftattrtab[] = { + { FLDT_DINODE_CORE, "dinode_core", NULL, (char *)inode_core_flds, + SI(bitsz(xfs_dinode_t)), 0, NULL, inode_core_flds }, + { FLDT_DINODE_FMT, "dinode_fmt", fp_dinode_fmt, NULL, +- SI(bitsz(__int8_t)), 0, NULL, NULL }, ++ SI(bitsz(int8_t)), 0, NULL, NULL }, + { FLDT_DINODE_U, "dinode_u", NULL, (char *)inode_u_flds, inode_u_size, + FTARG_SIZE|FTARG_OKEMPTY, NULL, inode_u_flds }, + { FLDT_DINODE_V3, "dinode_v3", NULL, (char *)inode_v3_flds, +@@ -295,7 +295,7 @@ const ftattr_t ftattrtab[] = { + { FLDT_DA3_NODE_HDR, "dir_node_hdr", NULL, (char *)da3_node_hdr_flds, + SI(bitsz(struct xfs_da3_node_hdr)), 0, NULL, da3_node_hdr_flds }, + +- { FLDT_DIRBLOCK, "dirblock", fp_num, "%u", SI(bitsz(__uint32_t)), 0, ++ { FLDT_DIRBLOCK, "dirblock", fp_num, "%u", SI(bitsz(uint32_t)), 0, + fa_dirblock, NULL }, + { FLDT_DISK_DQUOT, "disk_dquot", NULL, (char *)disk_dquot_flds, + SI(bitsz(xfs_disk_dquot_t)), 0, NULL, disk_dquot_flds }, +@@ -335,15 +335,15 @@ const ftattr_t ftattrtab[] = { + FTARG_SIZE, NULL, inode_crc_flds }, + { FLDT_INOFREE, "inofree", fp_num, "%#llx", SI(bitsz(xfs_inofree_t)), 0, + NULL, NULL }, +- { FLDT_INT16D, "int16d", fp_num, "%d", SI(bitsz(__int16_t)), ++ { FLDT_INT16D, "int16d", fp_num, "%d", SI(bitsz(int16_t)), + FTARG_SIGNED, NULL, NULL }, +- { FLDT_INT32D, "int32d", fp_num, "%d", SI(bitsz(__int32_t)), ++ { FLDT_INT32D, "int32d", fp_num, "%d", SI(bitsz(int32_t)), + FTARG_SIGNED, NULL, NULL }, +- { FLDT_INT64D, "int64d", fp_num, "%lld", SI(bitsz(__int64_t)), ++ { FLDT_INT64D, "int64d", fp_num, "%lld", SI(bitsz(int64_t)), + FTARG_SIGNED, NULL, NULL }, +- { FLDT_INT8D, "int8d", fp_num, "%d", SI(bitsz(__int8_t)), FTARG_SIGNED, ++ { FLDT_INT8D, "int8d", fp_num, "%d", SI(bitsz(int8_t)), FTARG_SIGNED, + NULL, NULL }, +- { FLDT_NSEC, "nsec", fp_num, "%09d", SI(bitsz(__int32_t)), FTARG_SIGNED, ++ { FLDT_NSEC, "nsec", fp_num, "%09d", SI(bitsz(int32_t)), FTARG_SIGNED, + NULL, NULL }, + { FLDT_QCNT, "qcnt", fp_num, "%llu", SI(bitsz(xfs_qcnt_t)), 0, NULL, + NULL }, +@@ -356,34 +356,34 @@ const ftattr_t ftattrtab[] = { + { FLDT_SYMLINK_CRC, "symlink", NULL, (char *)symlink_crc_flds, + symlink_size, FTARG_SIZE, NULL, symlink_crc_flds }, + +- { FLDT_TIME, "time", fp_time, NULL, SI(bitsz(__int32_t)), FTARG_SIGNED, ++ { FLDT_TIME, "time", fp_time, NULL, SI(bitsz(int32_t)), FTARG_SIGNED, + NULL, NULL }, + { FLDT_TIMESTAMP, "timestamp", NULL, (char *)timestamp_flds, + SI(bitsz(xfs_timestamp_t)), 0, NULL, timestamp_flds }, + { FLDT_UINT1, "uint1", fp_num, "%u", SI(1), 0, NULL, NULL }, +- { FLDT_UINT16D, "uint16d", fp_num, "%u", SI(bitsz(__uint16_t)), 0, NULL, ++ { FLDT_UINT16D, "uint16d", fp_num, "%u", SI(bitsz(uint16_t)), 0, NULL, + NULL }, +- { FLDT_UINT16O, "uint16o", fp_num, "%#o", SI(bitsz(__uint16_t)), 0, ++ { FLDT_UINT16O, "uint16o", fp_num, "%#o", SI(bitsz(uint16_t)), 0, + NULL, NULL }, +- { FLDT_UINT16X, "uint16x", fp_num, "%#x", SI(bitsz(__uint16_t)), 0, ++ { FLDT_UINT16X, "uint16x", fp_num, "%#x", SI(bitsz(uint16_t)), 0, + NULL, NULL }, +- { FLDT_UINT32D, "uint32d", fp_num, "%u", SI(bitsz(__uint32_t)), 0, NULL, ++ { FLDT_UINT32D, "uint32d", fp_num, "%u", SI(bitsz(uint32_t)), 0, NULL, + NULL }, +- { FLDT_UINT32O, "uint32o", fp_num, "%#o", SI(bitsz(__uint32_t)), 0, ++ { FLDT_UINT32O, "uint32o", fp_num, "%#o", SI(bitsz(uint32_t)), 0, + NULL, NULL }, +- { FLDT_UINT32X, "uint32x", fp_num, "%#x", SI(bitsz(__uint32_t)), 0, ++ { FLDT_UINT32X, "uint32x", fp_num, "%#x", SI(bitsz(uint32_t)), 0, + NULL, NULL }, +- { FLDT_UINT64D, "uint64d", fp_num, "%llu", SI(bitsz(__uint64_t)), 0, ++ { FLDT_UINT64D, "uint64d", fp_num, "%llu", SI(bitsz(uint64_t)), 0, + NULL, NULL }, +- { FLDT_UINT64O, "uint64o", fp_num, "%#llo", SI(bitsz(__uint64_t)), 0, ++ { FLDT_UINT64O, "uint64o", fp_num, "%#llo", SI(bitsz(uint64_t)), 0, + NULL, NULL }, +- { FLDT_UINT64X, "uint64x", fp_num, "%#llx", SI(bitsz(__uint64_t)), 0, ++ { FLDT_UINT64X, "uint64x", fp_num, "%#llx", SI(bitsz(uint64_t)), 0, + NULL, NULL }, +- { FLDT_UINT8D, "uint8d", fp_num, "%u", SI(bitsz(__uint8_t)), 0, NULL, ++ { FLDT_UINT8D, "uint8d", fp_num, "%u", SI(bitsz(uint8_t)), 0, NULL, + NULL }, +- { FLDT_UINT8O, "uint8o", fp_num, "%#o", SI(bitsz(__uint8_t)), 0, NULL, ++ { FLDT_UINT8O, "uint8o", fp_num, "%#o", SI(bitsz(uint8_t)), 0, NULL, + NULL }, +- { FLDT_UINT8X, "uint8x", fp_num, "%#x", SI(bitsz(__uint8_t)), 0, NULL, ++ { FLDT_UINT8X, "uint8x", fp_num, "%#x", SI(bitsz(uint8_t)), 0, NULL, + NULL }, + { FLDT_UUID, "uuid", fp_uuid, NULL, SI(bitsz(uuid_t)), 0, NULL, NULL }, + { FLDT_ZZZ, NULL } +diff --git a/db/fprint.c b/db/fprint.c +index fd7e7f45..261a31ef 100644 +--- a/db/fprint.c ++++ b/db/fprint.c +@@ -80,7 +80,7 @@ fp_num( + int bitpos; + int i; + int isnull; +- __int64_t val; ++ int64_t val; + + for (i = 0, bitpos = bit; + i < count && !seenint(); +@@ -100,7 +100,7 @@ fp_num( + else if (size > 32) + dbprintf(fmtstr, val); + else +- dbprintf(fmtstr, (__int32_t)val); ++ dbprintf(fmtstr, (int32_t)val); + if (i < count - 1) + dbprintf(" "); + } +@@ -203,7 +203,7 @@ fp_crc( + { + int bitpos; + int i; +- __int64_t val; ++ int64_t val; + char *ok; + + switch (iocur_crc_valid()) { +@@ -230,7 +230,7 @@ fp_crc( + if (size > 32) + dbprintf(fmtstr, val, ok); + else +- dbprintf(fmtstr, (__int32_t)val, ok); ++ dbprintf(fmtstr, (int32_t)val, ok); + if (i < count - 1) + dbprintf(" "); + } +diff --git a/db/frag.c b/db/frag.c +index 8005e45d..d224f0c2 100644 +--- a/db/frag.c ++++ b/db/frag.c +@@ -42,8 +42,8 @@ typedef struct extmap { + + static int aflag; + static int dflag; +-static __uint64_t extcount_actual; +-static __uint64_t extcount_ideal; ++static uint64_t extcount_actual; ++static uint64_t extcount_ideal; + static int fflag; + static int lflag; + static int qflag; +@@ -310,8 +310,8 @@ process_inode( + xfs_agino_t agino, + xfs_dinode_t *dip) + { +- __uint64_t actual; +- __uint64_t ideal; ++ uint64_t actual; ++ uint64_t ideal; + xfs_ino_t ino; + int skipa; + int skipd; +diff --git a/db/inode.c b/db/inode.c +index 8b7a41e4..6cc47d6a 100644 +--- a/db/inode.c ++++ b/db/inode.c +@@ -119,49 +119,49 @@ const field_t inode_core_flds[] = { + { "dmstate", FLDT_UINT16D, OI(COFF(dmstate)), C1, 0, TYP_NONE }, + { "flags", FLDT_UINT16X, OI(COFF(flags)), C1, FLD_SKIPALL, TYP_NONE }, + { "newrtbm", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NEWRTBM_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NEWRTBM_BIT - 1), C1, + 0, TYP_NONE }, + { "prealloc", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_PREALLOC_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_PREALLOC_BIT - 1), C1, + 0, TYP_NONE }, + { "realtime", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_REALTIME_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_REALTIME_BIT - 1), C1, + 0, TYP_NONE }, + { "immutable", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_IMMUTABLE_BIT-1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_IMMUTABLE_BIT-1), C1, + 0, TYP_NONE }, + { "append", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_APPEND_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_APPEND_BIT - 1), C1, + 0, TYP_NONE }, + { "sync", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_SYNC_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_SYNC_BIT - 1), C1, + 0, TYP_NONE }, + { "noatime", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NOATIME_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NOATIME_BIT - 1), C1, + 0, TYP_NONE }, + { "nodump", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NODUMP_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NODUMP_BIT - 1), C1, + 0, TYP_NONE }, + { "rtinherit", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_RTINHERIT_BIT-1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_RTINHERIT_BIT-1), C1, + 0, TYP_NONE }, + { "projinherit", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_PROJINHERIT_BIT-1),C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_PROJINHERIT_BIT-1), C1, + 0, TYP_NONE }, + { "nosymlinks", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NOSYMLINKS_BIT-1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NOSYMLINKS_BIT-1), C1, + 0, TYP_NONE }, + { "extsz", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_EXTSIZE_BIT-1),C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_EXTSIZE_BIT-1), C1, + 0, TYP_NONE }, + { "extszinherit", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_EXTSZINHERIT_BIT-1),C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_EXTSZINHERIT_BIT-1), C1, + 0, TYP_NONE }, + { "nodefrag", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NODEFRAG_BIT-1),C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NODEFRAG_BIT-1), C1, + 0, TYP_NONE }, + { "filestream", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_FILESTREAM_BIT-1),C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_FILESTREAM_BIT-1), C1, + 0, TYP_NONE }, + { "gen", FLDT_UINT32D, OI(COFF(gen)), C1, 0, TYP_NONE }, + { NULL } +@@ -177,10 +177,10 @@ const field_t inode_v3_flds[] = { + { "inumber", FLDT_INO, OI(COFF(ino)), C1, 0, TYP_NONE }, + { "uuid", FLDT_UUID, OI(COFF(uuid)), C1, 0, TYP_NONE }, + { "reflink", FLDT_UINT1, +- OI(COFF(flags2) + bitsz(__uint64_t) - XFS_DIFLAG2_REFLINK_BIT-1), C1, ++ OI(COFF(flags2) + bitsz(uint64_t) - XFS_DIFLAG2_REFLINK_BIT-1), C1, + 0, TYP_NONE }, + { "cowextsz", FLDT_UINT1, +- OI(COFF(flags2) + bitsz(__uint64_t) - XFS_DIFLAG2_COWEXTSIZE_BIT-1), C1, ++ OI(COFF(flags2) + bitsz(uint64_t) - XFS_DIFLAG2_COWEXTSIZE_BIT-1), C1, + 0, TYP_NONE }, + { NULL } + }; +diff --git a/db/io.c b/db/io.c +index 1f27f6b3..fd9b9f4b 100644 +--- a/db/io.c ++++ b/db/io.c +@@ -545,7 +545,7 @@ set_cur( + struct xfs_buf *bp; + xfs_ino_t dirino; + xfs_ino_t ino; +- __uint16_t mode; ++ uint16_t mode; + const struct xfs_buf_ops *ops = type ? type->bops : NULL; + + if (iocur_sp < 0) { +diff --git a/db/io.h b/db/io.h +index 99730048..df0fdd75 100644 +--- a/db/io.h ++++ b/db/io.h +@@ -25,7 +25,7 @@ typedef struct bbmap { + } bbmap_t; + + typedef struct iocur { +- __int64_t bb; /* BB number in filesystem of buf */ ++ int64_t bb; /* BB number in filesystem of buf */ + int blen; /* length of "buf", bb's */ + int boff; /* data - buf */ + void *buf; /* base address of buffer */ +@@ -33,7 +33,7 @@ typedef struct iocur { + xfs_ino_t dirino; /* current directory inode number */ + xfs_ino_t ino; /* current inode number */ + int len; /* length of "data", bytes */ +- __uint16_t mode; /* current inode's mode */ ++ uint16_t mode; /* current inode's mode */ + xfs_off_t off; /* fs offset of "data" in bytes */ + const struct typ *typ; /* type of "data" */ + bbmap_t *bbmap; /* map daddr if fragmented */ +@@ -57,7 +57,7 @@ extern void off_cur(int off, int len); + extern void pop_cur(void); + extern void print_iocur(char *tag, iocur_t *ioc); + extern void push_cur(void); +-extern int read_buf(__int64_t daddr, int count, void *bufp); ++extern int read_buf(int64_t daddr, int count, void *bufp); + extern void write_cur(void); + extern void set_cur(const struct typ *type, xfs_daddr_t blknum, + int len, int ring_add, bbmap_t *bbmap); +diff --git a/db/metadump.c b/db/metadump.c +index 31bb5959..67bdf14e 100644 +--- a/db/metadump.c ++++ b/db/metadump.c +@@ -175,7 +175,7 @@ write_index(void) + static int + write_buf_segment( + char *data, +- __int64_t off, ++ int64_t off, + int len) + { + int i; +@@ -1256,7 +1256,7 @@ process_sf_dir( + { + struct xfs_dir2_sf_hdr *sfp; + xfs_dir2_sf_entry_t *sfep; +- __uint64_t ino_dir_size; ++ uint64_t ino_dir_size; + int i; + + sfp = (struct xfs_dir2_sf_hdr *)XFS_DFORK_DPTR(dip); +@@ -1322,7 +1322,7 @@ process_sf_dir( + static void + obfuscate_path_components( + char *buf, +- __uint64_t len) ++ uint64_t len) + { + unsigned char *comp = (unsigned char *)buf; + unsigned char *end = comp + len; +@@ -1359,7 +1359,7 @@ static void + process_sf_symlink( + xfs_dinode_t *dip) + { +- __uint64_t len; ++ uint64_t len; + char *buf; + + len = be64_to_cpu(dip->di_size); +@@ -1631,7 +1631,7 @@ process_attr_block( + xfs_attr_leaf_entry_t *entry; + xfs_attr_leaf_name_local_t *local; + xfs_attr_leaf_name_remote_t *remote; +- __uint32_t bs = mp->m_sb.sb_blocksize; ++ uint32_t bs = mp->m_sb.sb_blocksize; + char *first_name; + + +@@ -2270,7 +2270,7 @@ done: + return success; + } + +-static __uint32_t inodes_copied = 0; ++static uint32_t inodes_copied; + + static int + copy_inode_chunk( +diff --git a/db/sb.c b/db/sb.c +index 8e7722cd..f19248d7 100644 +--- a/db/sb.c ++++ b/db/sb.c +@@ -606,7 +606,7 @@ version_help(void) + } + + static int +-do_version(xfs_agnumber_t agno, __uint16_t version, __uint32_t features) ++do_version(xfs_agnumber_t agno, uint16_t version, uint32_t features) + { + xfs_sb_t tsb; + +@@ -710,8 +710,8 @@ version_f( + int argc, + char **argv) + { +- __uint16_t version = 0; +- __uint32_t features = 0; ++ uint16_t version = 0; ++ uint32_t features = 0; + xfs_agnumber_t ag; + + if (argc == 2) { /* WRITE VERSION */ +diff --git a/fsr/xfs_fsr.c b/fsr/xfs_fsr.c +index 517b75f0..d4846a32 100644 +--- a/fsr/xfs_fsr.c ++++ b/fsr/xfs_fsr.c +@@ -54,7 +54,7 @@ struct getbmap *outmap = NULL; + int outmap_size = 0; + int RealUid; + int tmp_agi; +-static __int64_t minimumfree = 2048; ++static int64_t minimumfree = 2048; + + #define MNTTYPE_XFS "xfs" + +diff --git a/include/darwin.h b/include/darwin.h +index 7bbd5764..51031c42 100644 +--- a/include/darwin.h ++++ b/include/darwin.h +@@ -125,15 +125,15 @@ typedef signed int __s32; + typedef unsigned long long int __u64; + typedef signed long long int __s64; + +-#define __int8_t int8_t +-#define __int16_t int16_t +-#define __int32_t int32_t +-#define __int32_t int32_t +-#define __int64_t int64_t +-#define __uint8_t u_int8_t +-#define __uint16_t u_int16_t +-#define __uint32_t u_int32_t +-#define __uint64_t u_int64_t ++#define int8_t int8_t ++#define int16_t int16_t ++#define int32_t int32_t ++#define int32_t int32_t ++#define int64_t int64_t ++#define uint8_t u_int8_t ++#define uint16_t u_int16_t ++#define uint32_t u_int32_t ++#define uint64_t u_int64_t + + typedef off_t xfs_off_t; + typedef u_int64_t xfs_ino_t; +diff --git a/include/freebsd.h b/include/freebsd.h +index fb318b89..f52ed0a9 100644 +--- a/include/freebsd.h ++++ b/include/freebsd.h +@@ -50,9 +50,9 @@ typedef unsigned long long int __u64; + typedef signed long long int __s64; + + typedef off_t xfs_off_t; +-typedef __uint64_t xfs_ino_t; +-typedef __uint32_t xfs_dev_t; +-typedef __int64_t xfs_daddr_t; ++typedef uint64_t xfs_ino_t; ++typedef uint32_t xfs_dev_t; ++typedef int64_t xfs_daddr_t; + typedef __u32 xfs_nlink_t; + + #define O_LARGEFILE 0 +diff --git a/include/gnukfreebsd.h b/include/gnukfreebsd.h +index 6916e65a..1db3f4f0 100644 +--- a/include/gnukfreebsd.h ++++ b/include/gnukfreebsd.h +@@ -46,9 +46,9 @@ typedef unsigned long long int __u64; + typedef signed long long int __s64; + + typedef off_t xfs_off_t; +-typedef __uint64_t xfs_ino_t; +-typedef __uint32_t xfs_dev_t; +-typedef __int64_t xfs_daddr_t; ++typedef uint64_t xfs_ino_t; ++typedef uint32_t xfs_dev_t; ++typedef int64_t xfs_daddr_t; + typedef __u32 xfs_nlink_t; + + #define HAVE_FID 1 +diff --git a/include/libxcmd.h b/include/libxcmd.h +index e8d2ffc8..6806380c 100644 +--- a/include/libxcmd.h ++++ b/include/libxcmd.h +@@ -42,10 +42,10 @@ get_topology( + extern void + calc_default_ag_geometry( + int blocklog, +- __uint64_t dblocks, ++ uint64_t dblocks, + int multidisk, +- __uint64_t *agsize, +- __uint64_t *agcount); ++ uint64_t *agsize, ++ uint64_t *agcount); + + extern int + check_overwrite( +diff --git a/include/linux.h b/include/linux.h +index 9611a37f..6ce344c5 100644 +--- a/include/linux.h ++++ b/include/linux.h +@@ -132,7 +132,7 @@ static __inline__ void platform_uuid_copy(uuid_t *dst, uuid_t *src) + static __inline__ int + platform_discard_blocks(int fd, uint64_t start, uint64_t len) + { +- __uint64_t range[2] = { start, len }; ++ uint64_t range[2] = { start, len }; + + if (ioctl(fd, BLKDISCARD, &range) < 0) + return errno; +@@ -144,9 +144,9 @@ platform_discard_blocks(int fd, uint64_t start, uint64_t len) + #define EFSBADCRC EBADMSG /* Bad CRC detected */ + + typedef off_t xfs_off_t; +-typedef __uint64_t xfs_ino_t; +-typedef __uint32_t xfs_dev_t; +-typedef __int64_t xfs_daddr_t; ++typedef uint64_t xfs_ino_t; ++typedef uint32_t xfs_dev_t; ++typedef int64_t xfs_daddr_t; + typedef __u32 xfs_nlink_t; + + /** +diff --git a/include/xfs_arch.h b/include/xfs_arch.h +index 12cd43e6..186cadba 100644 +--- a/include/xfs_arch.h ++++ b/include/xfs_arch.h +@@ -244,39 +244,39 @@ static inline void be64_add_cpu(__be64 *a, __s64 b) + *a = cpu_to_be64(be64_to_cpu(*a) + b); + } + +-static inline __uint16_t get_unaligned_be16(void *p) ++static inline uint16_t get_unaligned_be16(void *p) + { +- __uint8_t *__p = p; ++ uint8_t *__p = p; + return __p[0] << 8 | __p[1]; + } + +-static inline __uint32_t get_unaligned_be32(void *p) ++static inline uint32_t get_unaligned_be32(void *p) + { +- __uint8_t *__p = p; ++ uint8_t *__p = p; + return __p[0] << 24 | __p[1] << 16 | __p[2] << 8 | __p[3]; + } + +-static inline __uint64_t get_unaligned_be64(void *p) ++static inline uint64_t get_unaligned_be64(void *p) + { +- return (__uint64_t)get_unaligned_be32(p) << 32 | ++ return (uint64_t)get_unaligned_be32(p) << 32 | + get_unaligned_be32(p + 4); + } + +-static inline void put_unaligned_be16(__uint16_t val, void *p) ++static inline void put_unaligned_be16(uint16_t val, void *p) + { +- __uint8_t *__p = p; ++ uint8_t *__p = p; + *__p++ = val >> 8; + *__p++ = val; + } + +-static inline void put_unaligned_be32(__uint32_t val, void *p) ++static inline void put_unaligned_be32(uint32_t val, void *p) + { +- __uint8_t *__p = p; ++ uint8_t *__p = p; + put_unaligned_be16(val >> 16, __p); + put_unaligned_be16(val, __p + 2); + } + +-static inline void put_unaligned_be64(__uint64_t val, void *p) ++static inline void put_unaligned_be64(uint64_t val, void *p) + { + put_unaligned_be32(val >> 32, p); + put_unaligned_be32(val, p + 4); +diff --git a/include/xfs_inode.h b/include/xfs_inode.h +index fb6b5429..8766024e 100644 +--- a/include/xfs_inode.h ++++ b/include/xfs_inode.h +@@ -123,8 +123,8 @@ xfs_get_projid(struct xfs_icdinode *id) + static inline void + xfs_set_projid(struct xfs_icdinode *id, prid_t projid) + { +- id->di_projid_hi = (__uint16_t) (projid >> 16); +- id->di_projid_lo = (__uint16_t) (projid & 0xffff); ++ id->di_projid_hi = (uint16_t) (projid >> 16); ++ id->di_projid_lo = (uint16_t) (projid & 0xffff); + } + + static inline bool xfs_is_reflink_inode(struct xfs_inode *ip) +diff --git a/include/xfs_log_recover.h b/include/xfs_log_recover.h +index 7582676b..0d098628 100644 +--- a/include/xfs_log_recover.h ++++ b/include/xfs_log_recover.h +@@ -26,7 +26,7 @@ + #define XLOG_RHASH_SIZE 16 + #define XLOG_RHASH_SHIFT 2 + #define XLOG_RHASH(tid) \ +- ((((__uint32_t)tid)>>XLOG_RHASH_SHIFT) & (XLOG_RHASH_SIZE-1)) ++ ((((uint32_t)tid)>>XLOG_RHASH_SHIFT) & (XLOG_RHASH_SIZE-1)) + + #define XLOG_MAX_REGIONS_IN_ITEM (XFS_MAX_BLOCKSIZE / XFS_BLF_CHUNK / 2 + 1) + +diff --git a/include/xfs_metadump.h b/include/xfs_metadump.h +index 7f3039eb..13afb8dd 100644 +--- a/include/xfs_metadump.h ++++ b/include/xfs_metadump.h +@@ -24,8 +24,8 @@ + typedef struct xfs_metablock { + __be32 mb_magic; + __be16 mb_count; +- __uint8_t mb_blocklog; +- __uint8_t mb_info; ++ uint8_t mb_blocklog; ++ uint8_t mb_info; + /* followed by an array of xfs_daddr_t */ + } xfs_metablock_t; + +diff --git a/include/xfs_mount.h b/include/xfs_mount.h +index 5ff24ebf..5b323bb1 100644 +--- a/include/xfs_mount.h ++++ b/include/xfs_mount.h +@@ -48,12 +48,12 @@ typedef struct xfs_mount { + #define m_dev m_ddev_targp + #define m_logdev m_logdev_targp + #define m_rtdev m_rtdev_targp +- __uint8_t m_dircook_elog; /* log d-cookie entry bits */ +- __uint8_t m_blkbit_log; /* blocklog + NBBY */ +- __uint8_t m_blkbb_log; /* blocklog - BBSHIFT */ +- __uint8_t m_sectbb_log; /* sectorlog - BBSHIFT */ +- __uint8_t m_agno_log; /* log #ag's */ +- __uint8_t m_agino_log; /* #bits for agino in inum */ ++ uint8_t m_dircook_elog; /* log d-cookie entry bits */ ++ uint8_t m_blkbit_log; /* blocklog + NBBY */ ++ uint8_t m_blkbb_log; /* blocklog - BBSHIFT */ ++ uint8_t m_sectbb_log; /* sectorlog - BBSHIFT */ ++ uint8_t m_agno_log; /* log #ag's */ ++ uint8_t m_agino_log; /* #bits for agino in inum */ + uint m_inode_cluster_size;/* min inode buf size */ + uint m_blockmask; /* sb_blocksize-1 */ + uint m_blockwsize; /* sb_blocksize in words */ +@@ -88,7 +88,7 @@ typedef struct xfs_mount { + int m_litino; /* size of inode union area */ + int m_inoalign_mask;/* mask sb_inoalignmt if used */ + struct xfs_trans_resv m_resv; /* precomputed res values */ +- __uint64_t m_maxicount; /* maximum inode count */ ++ uint64_t m_maxicount; /* maximum inode count */ + int m_dalign; /* stripe unit */ + int m_swidth; /* stripe width */ + int m_sinoalign; /* stripe unit inode alignmnt */ +@@ -144,12 +144,12 @@ typedef struct xfs_perag { + char pagi_init; /* this agi's entry is initialized */ + char pagf_metadata; /* the agf is preferred to be metadata */ + char pagi_inodeok; /* The agi is ok for inodes */ +- __uint8_t pagf_levels[XFS_BTNUM_AGF]; ++ uint8_t pagf_levels[XFS_BTNUM_AGF]; + /* # of levels in bno & cnt btree */ +- __uint32_t pagf_flcount; /* count of blocks in freelist */ ++ uint32_t pagf_flcount; /* count of blocks in freelist */ + xfs_extlen_t pagf_freeblks; /* total free blocks */ + xfs_extlen_t pagf_longest; /* longest free space */ +- __uint32_t pagf_btreeblks; /* # of blocks held in AGF btrees */ ++ uint32_t pagf_btreeblks; /* # of blocks held in AGF btrees */ + xfs_agino_t pagi_freecount; /* number of free inodes */ + xfs_agino_t pagi_count; /* number of allocated inodes */ + +@@ -169,7 +169,7 @@ typedef struct xfs_perag { + struct xfs_ag_resv pag_agfl_resv; + + /* reference count */ +- __uint8_t pagf_refcount_level; ++ uint8_t pagf_refcount_level; + } xfs_perag_t; + + static inline struct xfs_ag_resv * +diff --git a/libhandle/handle.c b/libhandle/handle.c +index 236ed22a..00127b3c 100644 +--- a/libhandle/handle.c ++++ b/libhandle/handle.c +@@ -232,7 +232,7 @@ obj_to_handle( + { + char hbuf [MAXHANSIZ]; + int ret; +- __uint32_t handlen; ++ uint32_t handlen; + xfs_fsop_handlereq_t hreq; + + if (opcode == XFS_IOC_FD_TO_HANDLE) { +diff --git a/libhandle/jdm.c b/libhandle/jdm.c +index e52f5d83..821061b4 100644 +--- a/libhandle/jdm.c ++++ b/libhandle/jdm.c +@@ -36,7 +36,7 @@ typedef struct filehandle { + fshandle_t fh_fshandle; /* handle of fs containing this inode */ + int16_t fh_sz_following; /* bytes in handle after this member */ + char fh_pad[FILEHANDLE_SZ_PAD]; /* padding, must be zeroed */ +- __uint32_t fh_gen; /* generation count */ ++ uint32_t fh_gen; /* generation count */ + xfs_ino_t fh_ino; /* 64 bit ino */ + } filehandle_t; + +diff --git a/libxcmd/topology.c b/libxcmd/topology.c +index 8b0276a7..f66dd1bc 100644 +--- a/libxcmd/topology.c ++++ b/libxcmd/topology.c +@@ -23,19 +23,19 @@ + #endif /* ENABLE_BLKID */ + #include "xfs_multidisk.h" + +-#define TERABYTES(count, blog) ((__uint64_t)(count) << (40 - (blog))) +-#define GIGABYTES(count, blog) ((__uint64_t)(count) << (30 - (blog))) +-#define MEGABYTES(count, blog) ((__uint64_t)(count) << (20 - (blog))) ++#define TERABYTES(count, blog) ((uint64_t)(count) << (40 - (blog))) ++#define GIGABYTES(count, blog) ((uint64_t)(count) << (30 - (blog))) ++#define MEGABYTES(count, blog) ((uint64_t)(count) << (20 - (blog))) + + void + calc_default_ag_geometry( + int blocklog, +- __uint64_t dblocks, ++ uint64_t dblocks, + int multidisk, +- __uint64_t *agsize, +- __uint64_t *agcount) ++ uint64_t *agsize, ++ uint64_t *agcount) + { +- __uint64_t blocks = 0; ++ uint64_t blocks = 0; + int shift = 0; + + /* +diff --git a/libxfs/darwin.c b/libxfs/darwin.c +index 74507e81..16d2c35c 100644 +--- a/libxfs/darwin.c ++++ b/libxfs/darwin.c +@@ -68,7 +68,7 @@ platform_flush_device(int fd, dev_t device) + void + platform_findsizes(char *path, int fd, long long *sz, int *bsz) + { +- __uint64_t size; ++ uint64_t size; + struct stat st; + + if (fstat(fd, &st) < 0) { +diff --git a/libxfs/freebsd.c b/libxfs/freebsd.c +index 4667d1f5..d7bca142 100644 +--- a/libxfs/freebsd.c ++++ b/libxfs/freebsd.c +@@ -109,7 +109,7 @@ void + platform_findsizes(char *path, int fd, long long *sz, int *bsz) + { + struct stat st; +- __int64_t size; ++ int64_t size; + u_int ssize; + + if (fstat(fd, &st) < 0) { +diff --git a/libxfs/init.c b/libxfs/init.c +index fc14c5e4..0f41a853 100644 +--- a/libxfs/init.c ++++ b/libxfs/init.c +@@ -546,7 +546,7 @@ libxfs_initialize_perag( + * the max inode percentage. + */ + if (mp->m_maxicount) { +- __uint64_t icount; ++ uint64_t icount; + + icount = sbp->sb_dblocks * sbp->sb_imax_pct; + do_div(icount, 100); +diff --git a/libxfs/irix.c b/libxfs/irix.c +index 32fcb3e5..0f14aec7 100644 +--- a/libxfs/irix.c ++++ b/libxfs/irix.c +@@ -22,7 +22,7 @@ + + int platform_has_uuid = 0; + extern char *progname; +-extern __int64_t findsize(char *); ++extern int64_t findsize(char *); + + int + platform_check_ismounted(char *name, char *block, struct stat *s, int verbose) +diff --git a/libxfs/libxfs_priv.h b/libxfs/libxfs_priv.h +index b4f766db..d525b667 100644 +--- a/libxfs/libxfs_priv.h ++++ b/libxfs/libxfs_priv.h +@@ -296,8 +296,8 @@ roundup_pow_of_two(uint v) + return 0; + } + +-static inline __uint64_t +-roundup_64(__uint64_t x, __uint32_t y) ++static inline uint64_t ++roundup_64(uint64_t x, uint32_t y) + { + x += y - 1; + do_div(x, y); +diff --git a/libxfs/linux.c b/libxfs/linux.c +index 69f04ad9..0bace3eb 100644 +--- a/libxfs/linux.c ++++ b/libxfs/linux.c +@@ -163,7 +163,7 @@ void + platform_findsizes(char *path, int fd, long long *sz, int *bsz) + { + struct stat st; +- __uint64_t size; ++ uint64_t size; + int error; + + if (fstat(fd, &st) < 0) { +diff --git a/libxfs/logitem.c b/libxfs/logitem.c +index 7e93f609..466b4421 100644 +--- a/libxfs/logitem.c ++++ b/libxfs/logitem.c +@@ -121,7 +121,7 @@ xfs_buf_item_init( + bip->bli_item.li_mountp = mp; + bip->bli_buf = bp; + bip->bli_format.blf_type = XFS_LI_BUF; +- bip->bli_format.blf_blkno = (__int64_t)XFS_BUF_ADDR(bp); ++ bip->bli_format.blf_blkno = (int64_t)XFS_BUF_ADDR(bp); + bip->bli_format.blf_len = (unsigned short)BTOBB(XFS_BUF_COUNT(bp)); + XFS_BUF_SET_FSPRIVATE(bp, bip); + } +diff --git a/libxfs/radix-tree.c b/libxfs/radix-tree.c +index eef9c36d..3f0257fe 100644 +--- a/libxfs/radix-tree.c ++++ b/libxfs/radix-tree.c +@@ -66,21 +66,21 @@ static unsigned long height_to_maxindex[RADIX_TREE_MAX_PATH]; + static inline void tag_set(struct radix_tree_node *node, unsigned int tag, + int offset) + { +- *((__uint32_t *)node->tags[tag] + (offset >> 5)) |= (1 << (offset & 31)); ++ *((uint32_t *)node->tags[tag] + (offset >> 5)) |= (1 << (offset & 31)); + } + + static inline void tag_clear(struct radix_tree_node *node, unsigned int tag, + int offset) + { +- __uint32_t *p = (__uint32_t*)node->tags[tag] + (offset >> 5); +- __uint32_t m = 1 << (offset & 31); ++ uint32_t *p = (uint32_t*)node->tags[tag] + (offset >> 5); ++ uint32_t m = 1 << (offset & 31); + *p &= ~m; + } + + static inline int tag_get(struct radix_tree_node *node, unsigned int tag, + int offset) + { +- return 1 & (((const __uint32_t *)node->tags[tag])[offset >> 5] >> (offset & 31)); ++ return 1 & (((const uint32_t *)node->tags[tag])[offset >> 5] >> (offset & 31)); + } + + /* +diff --git a/libxfs/rdwr.c b/libxfs/rdwr.c +index 21c42f14..474e5ebc 100644 +--- a/libxfs/rdwr.c ++++ b/libxfs/rdwr.c +@@ -118,9 +118,9 @@ static void unmount_record(void *p) + xlog_op_header_t *op = (xlog_op_header_t *)p; + /* the data section must be 32 bit size aligned */ + struct { +- __uint16_t magic; +- __uint16_t pad1; +- __uint32_t pad2; /* may as well make it 64 bits */ ++ uint16_t magic; ++ uint16_t pad1; ++ uint32_t pad2; /* may as well make it 64 bits */ + } magic = { XLOG_UNMOUNT_TYPE, 0, 0 }; + + memset(p, 0, BBSIZE); +diff --git a/libxfs/util.c b/libxfs/util.c +index dcfca397..7938e317 100644 +--- a/libxfs/util.c ++++ b/libxfs/util.c +@@ -170,8 +170,8 @@ libxfs_trans_ichgtime( + if (flags & XFS_ICHGTIME_CHG) + VFS_I(ip)->i_ctime = tv; + if (flags & XFS_ICHGTIME_CREATE) { +- ip->i_d.di_crtime.t_sec = (__int32_t)tv.tv_sec; +- ip->i_d.di_crtime.t_nsec = (__int32_t)tv.tv_nsec; ++ ip->i_d.di_crtime.t_sec = (int32_t)tv.tv_sec; ++ ip->i_d.di_crtime.t_nsec = (int32_t)tv.tv_nsec; + } + } + +@@ -261,8 +261,8 @@ libxfs_ialloc( + ASSERT(uuid_equal(&ip->i_d.di_uuid, &mp->m_sb.sb_meta_uuid)); + VFS_I(ip)->i_version = 1; + ip->i_d.di_flags2 = 0; +- ip->i_d.di_crtime.t_sec = (__int32_t)VFS_I(ip)->i_mtime.tv_sec; +- ip->i_d.di_crtime.t_nsec = (__int32_t)VFS_I(ip)->i_mtime.tv_nsec; ++ ip->i_d.di_crtime.t_sec = (int32_t)VFS_I(ip)->i_mtime.tv_sec; ++ ip->i_d.di_crtime.t_nsec = (int32_t)VFS_I(ip)->i_mtime.tv_nsec; + } + + flags = XFS_ILOG_CORE; +diff --git a/logprint/log_misc.c b/logprint/log_misc.c +index 0dfcfd19..2fd01ceb 100644 +--- a/logprint/log_misc.c ++++ b/logprint/log_misc.c +@@ -166,12 +166,12 @@ xlog_print_trans_header(char **ptr, int len) + { + xfs_trans_header_t *h; + char *cptr = *ptr; +- __uint32_t magic; ++ uint32_t magic; + char *magic_c = (char *)&magic; + + *ptr += len; + +- magic=*(__uint32_t*)cptr; /* XXX be32_to_cpu soon */ ++ magic = *(uint32_t *)cptr; /* XXX be32_to_cpu soon */ + + if (len >= 4) { + #if __BYTE_ORDER == __LITTLE_ENDIAN +@@ -201,7 +201,7 @@ xlog_print_trans_buffer(char **ptr, int len, int *i, int num_ops) + int num, skip; + int super_block = 0; + int bucket, col, buckets; +- __int64_t blkno; ++ int64_t blkno; + xfs_buf_log_format_t lbuf; + int size, blen, map_size, struct_size; + __be64 x, y; +diff --git a/mdrestore/xfs_mdrestore.c b/mdrestore/xfs_mdrestore.c +index 9d1b4e80..c49c13aa 100644 +--- a/mdrestore/xfs_mdrestore.c ++++ b/mdrestore/xfs_mdrestore.c +@@ -66,7 +66,7 @@ perform_restore( + int mb_count; + xfs_metablock_t tmb; + xfs_sb_t sb; +- __int64_t bytes_read; ++ int64_t bytes_read; + + /* + * read in first blocks (superblock 0), set "inprogress" flag for it, +diff --git a/mkfs/proto.c b/mkfs/proto.c +index 89cd2379..cf8cc391 100644 +--- a/mkfs/proto.c ++++ b/mkfs/proto.c +@@ -667,7 +667,7 @@ rtinit( + mp->m_sb.sb_rbmino = rbmip->i_ino; + rbmip->i_d.di_size = mp->m_sb.sb_rbmblocks * mp->m_sb.sb_blocksize; + rbmip->i_d.di_flags = XFS_DIFLAG_NEWRTBM; +- *(__uint64_t *)&VFS_I(rbmip)->i_atime = 0; ++ *(uint64_t *)&VFS_I(rbmip)->i_atime = 0; + libxfs_trans_log_inode(tp, rbmip, XFS_ILOG_CORE); + libxfs_log_sb(tp); + mp->m_rbmip = rbmip; +diff --git a/mkfs/xfs_mkfs.c b/mkfs/xfs_mkfs.c +index b5c3a57e..7bb6408f 100644 +--- a/mkfs/xfs_mkfs.c ++++ b/mkfs/xfs_mkfs.c +@@ -705,9 +705,9 @@ struct opt_params mopts = { + }, + }; + +-#define TERABYTES(count, blog) ((__uint64_t)(count) << (40 - (blog))) +-#define GIGABYTES(count, blog) ((__uint64_t)(count) << (30 - (blog))) +-#define MEGABYTES(count, blog) ((__uint64_t)(count) << (20 - (blog))) ++#define TERABYTES(count, blog) ((uint64_t)(count) << (40 - (blog))) ++#define GIGABYTES(count, blog) ((uint64_t)(count) << (30 - (blog))) ++#define MEGABYTES(count, blog) ((uint64_t)(count) << (20 - (blog))) + + /* + * Use this macro before we have superblock and mount structure +@@ -878,7 +878,7 @@ fixup_log_stripe_unit( + xfs_rfsblock_t *logblocks, + int blocklog) + { +- __uint64_t tmp_logblocks; ++ uint64_t tmp_logblocks; + + /* + * Make sure that the log size is a multiple of the stripe unit +@@ -910,7 +910,7 @@ fixup_internal_log_stripe( + xfs_mount_t *mp, + int lsflag, + xfs_fsblock_t logstart, +- __uint64_t agsize, ++ uint64_t agsize, + int sunit, + xfs_rfsblock_t *logblocks, + int blocklog, +@@ -934,7 +934,7 @@ fixup_internal_log_stripe( + } + + void +-validate_log_size(__uint64_t logblocks, int blocklog, int min_logblocks) ++validate_log_size(uint64_t logblocks, int blocklog, int min_logblocks) + { + if (logblocks < min_logblocks) { + fprintf(stderr, +@@ -959,7 +959,7 @@ validate_log_size(__uint64_t logblocks, int blocklog, int min_logblocks) + static int + calc_default_imaxpct( + int blocklog, +- __uint64_t dblocks) ++ uint64_t dblocks) + { + /* + * This returns the % of the disk space that is used for +@@ -981,9 +981,9 @@ calc_default_imaxpct( + static void + validate_ag_geometry( + int blocklog, +- __uint64_t dblocks, +- __uint64_t agsize, +- __uint64_t agcount) ++ uint64_t dblocks, ++ uint64_t agsize, ++ uint64_t agcount) + { + if (agsize < XFS_AG_MIN_BLOCKS(blocklog)) { + fprintf(stderr, +@@ -1059,7 +1059,7 @@ zero_old_xfs_structures( + { + void *buf; + xfs_sb_t sb; +- __uint32_t bsize; ++ uint32_t bsize; + int i; + xfs_off_t off; + +@@ -1112,8 +1112,8 @@ zero_old_xfs_structures( + i != sb.sb_blocklog) + goto done; + +- if (sb.sb_dblocks > ((__uint64_t)sb.sb_agcount * sb.sb_agblocks) || +- sb.sb_dblocks < ((__uint64_t)(sb.sb_agcount - 1) * ++ if (sb.sb_dblocks > ((uint64_t)sb.sb_agcount * sb.sb_agblocks) || ++ sb.sb_dblocks < ((uint64_t)(sb.sb_agcount - 1) * + sb.sb_agblocks + XFS_MIN_AG_BLOCKS)) + goto done; + +@@ -1133,7 +1133,7 @@ done: + } + + static void +-discard_blocks(dev_t dev, __uint64_t nsectors) ++discard_blocks(dev_t dev, uint64_t nsectors) + { + int fd; + +@@ -1395,11 +1395,11 @@ main( + int argc, + char **argv) + { +- __uint64_t agcount; ++ uint64_t agcount; + xfs_agf_t *agf; + xfs_agi_t *agi; + xfs_agnumber_t agno; +- __uint64_t agsize; ++ uint64_t agsize; + xfs_alloc_rec_t *arec; + struct xfs_btree_block *block; + int blflag; +@@ -1475,10 +1475,10 @@ main( + char *rtsize; + xfs_sb_t *sbp; + int sectorlog; +- __uint64_t sector_mask; ++ uint64_t sector_mask; + int slflag; + int ssflag; +- __uint64_t tmp_agsize; ++ uint64_t tmp_agsize; + uuid_t uuid; + int worst_freelist; + libxfs_init_t xi; +@@ -2167,7 +2167,7 @@ _("rmapbt not supported with realtime devices\n")); + + + if (dsize) { +- __uint64_t dbytes; ++ uint64_t dbytes; + + dbytes = getnum(dsize, &dopts, D_SIZE); + if (dbytes % XFS_MIN_BLOCKSIZE) { +@@ -2199,7 +2199,7 @@ _("rmapbt not supported with realtime devices\n")); + } + + if (logsize) { +- __uint64_t logbytes; ++ uint64_t logbytes; + + logbytes = getnum(logsize, &lopts, L_SIZE); + if (logbytes % XFS_MIN_BLOCKSIZE) { +@@ -2216,7 +2216,7 @@ _("rmapbt not supported with realtime devices\n")); + (long long)(logblocks << blocklog)); + } + if (rtsize) { +- __uint64_t rtbytes; ++ uint64_t rtbytes; + + rtbytes = getnum(rtsize, &ropts, R_SIZE); + if (rtbytes % XFS_MIN_BLOCKSIZE) { +@@ -2236,7 +2236,7 @@ _("rmapbt not supported with realtime devices\n")); + * If specified, check rt extent size against its constraints. + */ + if (rtextsize) { +- __uint64_t rtextbytes; ++ uint64_t rtextbytes; + + rtextbytes = getnum(rtextsize, &ropts, R_EXTSIZE); + if (rtextbytes % blocksize) { +@@ -2252,8 +2252,8 @@ _("rmapbt not supported with realtime devices\n")); + * and the underlying volume is striped, then set rtextblocks + * to the stripe width. + */ +- __uint64_t rswidth; +- __uint64_t rtextbytes; ++ uint64_t rswidth; ++ uint64_t rtextbytes; + + if (!norsflag && !xi.risfile && !(!rtsize && xi.disfile)) + rswidth = ft.rtswidth; +@@ -2335,10 +2335,10 @@ _("rmapbt not supported with realtime devices\n")); + * multiple of the sector size, or 1024, whichever is larger. + */ + +- sector_mask = (__uint64_t)-1 << (MAX(sectorlog, 10) - BBSHIFT); ++ sector_mask = (uint64_t)-1 << (MAX(sectorlog, 10) - BBSHIFT); + xi.dsize &= sector_mask; + xi.rtsize &= sector_mask; +- xi.logBBsize &= (__uint64_t)-1 << (MAX(lsectorlog, 10) - BBSHIFT); ++ xi.logBBsize &= (uint64_t)-1 << (MAX(lsectorlog, 10) - BBSHIFT); + + + /* don't do discards on print-only runs or on files */ +@@ -2696,9 +2696,9 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"), + mp = &mbuf; + sbp = &mp->m_sb; + memset(mp, 0, sizeof(xfs_mount_t)); +- sbp->sb_blocklog = (__uint8_t)blocklog; +- sbp->sb_sectlog = (__uint8_t)sectorlog; +- sbp->sb_agblklog = (__uint8_t)libxfs_log2_roundup((unsigned int)agsize); ++ sbp->sb_blocklog = (uint8_t)blocklog; ++ sbp->sb_sectlog = (uint8_t)sectorlog; ++ sbp->sb_agblklog = (uint8_t)libxfs_log2_roundup((unsigned int)agsize); + sbp->sb_agblocks = (xfs_agblock_t)agsize; + mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT; + mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT; +@@ -2805,14 +2805,14 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"), + sbp->sb_agcount = (xfs_agnumber_t)agcount; + sbp->sb_rbmblocks = nbmblocks; + sbp->sb_logblocks = (xfs_extlen_t)logblocks; +- sbp->sb_sectsize = (__uint16_t)sectorsize; +- sbp->sb_inodesize = (__uint16_t)isize; +- sbp->sb_inopblock = (__uint16_t)(blocksize / isize); +- sbp->sb_sectlog = (__uint8_t)sectorlog; +- sbp->sb_inodelog = (__uint8_t)inodelog; +- sbp->sb_inopblog = (__uint8_t)(blocklog - inodelog); ++ sbp->sb_sectsize = (uint16_t)sectorsize; ++ sbp->sb_inodesize = (uint16_t)isize; ++ sbp->sb_inopblock = (uint16_t)(blocksize / isize); ++ sbp->sb_sectlog = (uint8_t)sectorlog; ++ sbp->sb_inodelog = (uint8_t)inodelog; ++ sbp->sb_inopblog = (uint8_t)(blocklog - inodelog); + sbp->sb_rextslog = +- (__uint8_t)(rtextents ? ++ (uint8_t)(rtextents ? + libxfs_highbit32((unsigned int)rtextents) : 0); + sbp->sb_inprogress = 1; /* mkfs is in progress */ + sbp->sb_imax_pct = imaxpct; +@@ -2840,8 +2840,8 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"), + } else + sbp->sb_inoalignmt = 0; + if (lsectorsize != BBSIZE || sectorsize != BBSIZE) { +- sbp->sb_logsectlog = (__uint8_t)lsectorlog; +- sbp->sb_logsectsize = (__uint16_t)lsectorsize; ++ sbp->sb_logsectlog = (uint8_t)lsectorlog; ++ sbp->sb_logsectsize = (uint16_t)lsectorsize; + } else { + sbp->sb_logsectlog = 0; + sbp->sb_logsectsize = 0; +diff --git a/quota/edit.c b/quota/edit.c +index 36b327a5..8418e858 100644 +--- a/quota/edit.c ++++ b/quota/edit.c +@@ -115,16 +115,16 @@ warn_help(void) + + static void + set_limits( +- __uint32_t id, ++ uint32_t id, + uint type, + uint mask, + char *dev, +- __uint64_t *bsoft, +- __uint64_t *bhard, +- __uint64_t *isoft, +- __uint64_t *ihard, +- __uint64_t *rtbsoft, +- __uint64_t *rtbhard) ++ uint64_t *bsoft, ++ uint64_t *bhard, ++ uint64_t *isoft, ++ uint64_t *ihard, ++ uint64_t *rtbsoft, ++ uint64_t *rtbhard) + { + fs_disk_quota_t d; + +@@ -152,12 +152,12 @@ set_user_limits( + char *name, + uint type, + uint mask, +- __uint64_t *bsoft, +- __uint64_t *bhard, +- __uint64_t *isoft, +- __uint64_t *ihard, +- __uint64_t *rtbsoft, +- __uint64_t *rtbhard) ++ uint64_t *bsoft, ++ uint64_t *bhard, ++ uint64_t *isoft, ++ uint64_t *ihard, ++ uint64_t *rtbsoft, ++ uint64_t *rtbhard) + { + uid_t uid = uid_from_string(name); + +@@ -175,12 +175,12 @@ set_group_limits( + char *name, + uint type, + uint mask, +- __uint64_t *bsoft, +- __uint64_t *bhard, +- __uint64_t *isoft, +- __uint64_t *ihard, +- __uint64_t *rtbsoft, +- __uint64_t *rtbhard) ++ uint64_t *bsoft, ++ uint64_t *bhard, ++ uint64_t *isoft, ++ uint64_t *ihard, ++ uint64_t *rtbsoft, ++ uint64_t *rtbhard) + { + gid_t gid = gid_from_string(name); + +@@ -198,12 +198,12 @@ set_project_limits( + char *name, + uint type, + uint mask, +- __uint64_t *bsoft, +- __uint64_t *bhard, +- __uint64_t *isoft, +- __uint64_t *ihard, +- __uint64_t *rtbsoft, +- __uint64_t *rtbhard) ++ uint64_t *bsoft, ++ uint64_t *bhard, ++ uint64_t *isoft, ++ uint64_t *ihard, ++ uint64_t *rtbsoft, ++ uint64_t *rtbhard) + { + prid_t prid = prid_from_string(name); + +@@ -224,7 +224,7 @@ extractb( + int length, + uint blocksize, + uint sectorsize, +- __uint64_t *value) ++ uint64_t *value) + { + long long v; + char *s = string; +@@ -238,7 +238,7 @@ extractb( + progname, s); + return 0; + } +- *value = (__uint64_t)v >> 9; /* syscalls use basic blocks */ ++ *value = (uint64_t)v >> 9; /* syscalls use basic blocks */ + if (v > 0 && *value == 0) + fprintf(stderr, _("%s: Warning: `%s' in quota blocks is 0 (unlimited).\n"), progname, s); + return 1; +@@ -252,7 +252,7 @@ extracti( + char *string, + const char *prefix, + int length, +- __uint64_t *value) ++ uint64_t *value) + { + char *sp, *s = string; + +@@ -270,7 +270,7 @@ limit_f( + char **argv) + { + char *name; +- __uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard; ++ uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard; + int c, type = 0, mask = 0, flags = 0; + uint bsize, ssize, endoptions; + +@@ -384,8 +384,8 @@ restore_file( + char *dev = NULL; + uint mask; + int cnt; +- __uint32_t id; +- __uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard; ++ uint32_t id; ++ uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard; + + while (fgets(buffer, sizeof(buffer), fp) != NULL) { + if (strncmp("fs = ", buffer, 5) == 0) { +@@ -546,7 +546,7 @@ timer_f( + + static void + set_warnings( +- __uint32_t id, ++ uint32_t id, + uint type, + uint mask, + char *dev, +diff --git a/quota/free.c b/quota/free.c +index cee15ee9..1f8378d2 100644 +--- a/quota/free.c ++++ b/quota/free.c +@@ -49,20 +49,20 @@ free_help(void) + static int + mount_free_space_data( + struct fs_path *mount, +- __uint64_t *bcount, +- __uint64_t *bused, +- __uint64_t *bfree, +- __uint64_t *icount, +- __uint64_t *iused, +- __uint64_t *ifree, +- __uint64_t *rcount, +- __uint64_t *rused, +- __uint64_t *rfree) ++ uint64_t *bcount, ++ uint64_t *bused, ++ uint64_t *bfree, ++ uint64_t *icount, ++ uint64_t *iused, ++ uint64_t *ifree, ++ uint64_t *rcount, ++ uint64_t *rused, ++ uint64_t *rfree) + { + struct xfs_fsop_counts fscounts; + struct xfs_fsop_geom fsgeo; + struct statfs st; +- __uint64_t logsize, count, free; ++ uint64_t logsize, count, free; + int fd; + + if ((fd = open(mount->fs_dir, O_RDONLY)) < 0) { +@@ -132,15 +132,15 @@ mount_free_space_data( + static int + projects_free_space_data( + struct fs_path *path, +- __uint64_t *bcount, +- __uint64_t *bused, +- __uint64_t *bfree, +- __uint64_t *icount, +- __uint64_t *iused, +- __uint64_t *ifree, +- __uint64_t *rcount, +- __uint64_t *rused, +- __uint64_t *rfree) ++ uint64_t *bcount, ++ uint64_t *bused, ++ uint64_t *bfree, ++ uint64_t *icount, ++ uint64_t *iused, ++ uint64_t *ifree, ++ uint64_t *rcount, ++ uint64_t *rused, ++ uint64_t *rfree) + { + fs_quota_stat_t qfs; + fs_disk_quota_t d; +@@ -226,9 +226,9 @@ free_space( + fs_path_t *path, + uint flags) + { +- __uint64_t bcount, bused, bfree; +- __uint64_t icount, iused, ifree; +- __uint64_t rcount, rused, rfree; ++ uint64_t bcount, bused, bfree; ++ uint64_t icount, iused, ifree; ++ uint64_t rcount, rused, rfree; + char a[8], s[8], u[8], p[8]; + int count; + +diff --git a/quota/quot.c b/quota/quot.c +index ccc154f5..6378fbb7 100644 +--- a/quota/quot.c ++++ b/quota/quot.c +@@ -26,17 +26,17 @@ + + typedef struct du { + struct du *next; +- __uint64_t blocks; +- __uint64_t blocks30; +- __uint64_t blocks60; +- __uint64_t blocks90; +- __uint64_t nfiles; +- __uint32_t id; ++ uint64_t blocks; ++ uint64_t blocks30; ++ uint64_t blocks60; ++ uint64_t blocks90; ++ uint64_t nfiles; ++ uint32_t id; + } du_t; + + #define TSIZE 500 +-static __uint64_t sizes[TSIZE]; +-static __uint64_t overflow; ++static uint64_t sizes[TSIZE]; ++static uint64_t overflow; + + #define NDU 60000 + #define DUHASH 8209 +@@ -84,8 +84,8 @@ quot_bulkstat_add( + { + du_t *dp; + du_t **hp; +- __uint64_t size; +- __uint32_t i, id; ++ uint64_t size; ++ uint32_t i, id; + + if ((p->bs_mode & S_IFMT) == 0) + return; +@@ -203,7 +203,7 @@ qcompare( + return 0; + } + +-typedef char *(*idtoname_t)(__uint32_t); ++typedef char *(*idtoname_t)(uint32_t); + + static void + quot_report_mount_any_type( +@@ -291,7 +291,7 @@ quot_histogram_mount( + fs_path_t *mount, + uint flags) + { +- __uint64_t t = 0; ++ uint64_t t = 0; + int i; + + fprintf(fp, _("%s (%s):\n"), mount->fs_name, mount->fs_dir); +diff --git a/quota/quota.c b/quota/quota.c +index d09e239b..479b970e 100644 +--- a/quota/quota.c ++++ b/quota/quota.c +@@ -52,7 +52,7 @@ quota_help(void) + static int + quota_mount( + FILE *fp, +- __uint32_t id, ++ uint32_t id, + char *name, + uint form, + uint type, +@@ -181,7 +181,7 @@ quota_mount( + static void + quota( + FILE *fp, +- __uint32_t id, ++ uint32_t id, + char *name, + uint form, + uint type, +diff --git a/quota/quota.h b/quota/quota.h +index 4bde3513..9ed28bee 100644 +--- a/quota/quota.h ++++ b/quota/quota.h +@@ -53,9 +53,9 @@ enum { + extern char *type_to_string(uint __type); + extern char *form_to_string(uint __form); + extern char *time_to_string(time_t __time, uint __flags); +-extern char *bbs_to_string(__uint64_t __v, char *__c, uint __size); +-extern char *num_to_string(__uint64_t __v, char *__c, uint __size); +-extern char *pct_to_string(__uint64_t __v, __uint64_t __t, char *__c, uint __s); ++extern char *bbs_to_string(uint64_t __v, char *__c, uint __size); ++extern char *num_to_string(uint64_t __v, char *__c, uint __size); ++extern char *pct_to_string(uint64_t __v, uint64_t __t, char *__c, uint __s); + + extern FILE *fopen_write_secure(char *__filename); + +@@ -81,7 +81,7 @@ enum { + * Identifier (uid/gid/prid) cache routines + */ + #define NMAX 32 +-extern char *uid_to_name(__uint32_t __uid); +-extern char *gid_to_name(__uint32_t __gid); +-extern char *prid_to_name(__uint32_t __prid); ++extern char *uid_to_name(uint32_t __uid); ++extern char *gid_to_name(uint32_t __gid); ++extern char *prid_to_name(uint32_t __prid); + extern bool isdigits_only(const char *); +diff --git a/quota/report.c b/quota/report.c +index d0509c25..b2ea3bbe 100644 +--- a/quota/report.c ++++ b/quota/report.c +@@ -333,9 +333,9 @@ report_header( + static int + report_mount( + FILE *fp, +- __uint32_t id, ++ uint32_t id, + char *name, +- __uint32_t *oid, ++ uint32_t *oid, + uint form, + uint type, + fs_path_t *mount, +diff --git a/quota/state.c b/quota/state.c +index 09dfa705..b08bf50b 100644 +--- a/quota/state.c ++++ b/quota/state.c +@@ -135,7 +135,7 @@ static void + state_timelimit( + FILE *fp, + uint form, +- __uint32_t timelimit) ++ uint32_t timelimit) + { + fprintf(fp, _("%s grace time: %s\n"), + form_to_string(form), +diff --git a/quota/util.c b/quota/util.c +index cafd45f5..37840a86 100644 +--- a/quota/util.c ++++ b/quota/util.c +@@ -94,8 +94,8 @@ round_snprintf( + size_t size, + const char *fmt_round, + const char *fmt_not_round, +- __uint64_t value, +- __uint64_t divisor) ++ uint64_t value, ++ uint64_t divisor) + { + double v = (double)value / divisor; + +@@ -107,23 +107,23 @@ round_snprintf( + } + + /* Basic blocks (512) bytes are returned from quotactl */ +-#define BBS_TO_EXABYTES(bbs) ((__uint64_t)(bbs)>>51) +-#define BBS_TO_PETABYTES(bbs) ((__uint64_t)(bbs)>>41) +-#define BBS_TO_TERABYTES(bbs) ((__uint64_t)(bbs)>>31) +-#define BBS_TO_GIGABYTES(bbs) ((__uint64_t)(bbs)>>21) +-#define BBS_TO_MEGABYTES(bbs) ((__uint64_t)(bbs)>>11) +-#define BBS_TO_KILOBYTES(bbs) ((__uint64_t)(bbs)>>1) +- +-#define BBEXABYTE ((__uint64_t)1<<51) +-#define BBPETABYTE ((__uint64_t)1<<41) +-#define BBTERABYTE ((__uint64_t)1<<31) +-#define BBGIGABYTE ((__uint64_t)1<<21) +-#define BBMEGABYTE ((__uint64_t)1<<11) +-#define BBKILOBYTE ((__uint64_t)1<< 1) ++#define BBS_TO_EXABYTES(bbs) ((uint64_t)(bbs)>>51) ++#define BBS_TO_PETABYTES(bbs) ((uint64_t)(bbs)>>41) ++#define BBS_TO_TERABYTES(bbs) ((uint64_t)(bbs)>>31) ++#define BBS_TO_GIGABYTES(bbs) ((uint64_t)(bbs)>>21) ++#define BBS_TO_MEGABYTES(bbs) ((uint64_t)(bbs)>>11) ++#define BBS_TO_KILOBYTES(bbs) ((uint64_t)(bbs)>>1) ++ ++#define BBEXABYTE ((uint64_t)1<<51) ++#define BBPETABYTE ((uint64_t)1<<41) ++#define BBTERABYTE ((uint64_t)1<<31) ++#define BBGIGABYTE ((uint64_t)1<<21) ++#define BBMEGABYTE ((uint64_t)1<<11) ++#define BBKILOBYTE ((uint64_t)1<< 1) + + char * + bbs_to_string( +- __uint64_t v, ++ uint64_t v, + char *sp, + uint size) + { +@@ -146,17 +146,17 @@ bbs_to_string( + return sp; + } + +-#define THOUSAND ((__uint64_t)1000) +-#define MILLION ((__uint64_t)1000*1000) +-#define BILLION ((__uint64_t)1000*1000*1000) +-#define TRILLION ((__uint64_t)1000*1000*1000*1000) +-#define GAZILLION ((__uint64_t)1000*1000*1000*1000*1000) +-#define RIDICULOUS ((__uint64_t)1000*1000*1000*1000*1000*1000) +-#define STOPALREADY ((__uint64_t)1000*1000*1000*1000*1000*1000*1000) ++#define THOUSAND ((uint64_t)1000) ++#define MILLION ((uint64_t)1000*1000) ++#define BILLION ((uint64_t)1000*1000*1000) ++#define TRILLION ((uint64_t)1000*1000*1000*1000) ++#define GAZILLION ((uint64_t)1000*1000*1000*1000*1000) ++#define RIDICULOUS ((uint64_t)1000*1000*1000*1000*1000*1000) ++#define STOPALREADY ((uint64_t)1000*1000*1000*1000*1000*1000*1000) + + char * + num_to_string( +- __uint64_t v, ++ uint64_t v, + char *sp, + uint size) + { +@@ -183,8 +183,8 @@ num_to_string( + + char * + pct_to_string( +- __uint64_t portion, +- __uint64_t whole, ++ uint64_t portion, ++ uint64_t whole, + char *buf, + uint size) + { +@@ -237,7 +237,7 @@ type_to_string( + #define IDMASK (NID-1) + + typedef struct { +- __uint32_t id; ++ uint32_t id; + char name[NMAX+1]; + } idcache_t; + +@@ -250,7 +250,7 @@ static int pentriesleft = NID; + + static idcache_t * + getnextpwent( +- __uint32_t id, ++ uint32_t id, + int byid) + { + struct passwd *pw; +@@ -266,7 +266,7 @@ getnextpwent( + + static idcache_t * + getnextgrent( +- __uint32_t id, ++ uint32_t id, + int byid) + { + struct group *gr; +@@ -281,7 +281,7 @@ getnextgrent( + + static idcache_t * + getnextprent( +- __uint32_t id, ++ uint32_t id, + int byid) + { + fs_project_t *pr; +@@ -296,7 +296,7 @@ getnextprent( + + char * + uid_to_name( +- __uint32_t id) ++ uint32_t id) + { + idcache_t *ncp, *idp; + +@@ -333,7 +333,7 @@ uid_to_name( + + char * + gid_to_name( +- __uint32_t id) ++ uint32_t id) + { + idcache_t *ncp, *idp; + +@@ -370,7 +370,7 @@ gid_to_name( + + char * + prid_to_name( +- __uint32_t id) ++ uint32_t id) + { + idcache_t *ncp, *idp; + +diff --git a/repair/README b/repair/README +index 7f168e69..4692463d 100644 +--- a/repair/README ++++ b/repair/README +@@ -189,7 +189,7 @@ D - 0) look at usage of XFS_MAKE_IPTR(). It does the right + + + D - 0) look at references to XFS_INODES_PER_CHUNK. change the +- ones that really mean sizeof(__uint64_t)*NBBY to ++ ones that really mean sizeof(uint64_t)*NBBY to + something else (like that only defined as a constant + INOS_PER_IREC. this isn't as important since + XFS_INODES_PER_CHUNK will never chang +diff --git a/repair/agheader.h b/repair/agheader.h +index 6b2974ca..2f7246d2 100644 +--- a/repair/agheader.h ++++ b/repair/agheader.h +@@ -20,7 +20,7 @@ typedef struct fs_geometry { + /* + * these types should match the superblock types + */ +- __uint32_t sb_blocksize; /* blocksize (bytes) */ ++ uint32_t sb_blocksize; /* blocksize (bytes) */ + xfs_rfsblock_t sb_dblocks; /* # data blocks */ + xfs_rfsblock_t sb_rblocks; /* # realtime blocks */ + xfs_rtblock_t sb_rextents; /* # realtime extents */ +@@ -30,9 +30,9 @@ typedef struct fs_geometry { + xfs_agnumber_t sb_agcount; /* # of ags */ + xfs_extlen_t sb_rbmblocks; /* # of rt bitmap blocks */ + xfs_extlen_t sb_logblocks; /* # of log blocks */ +- __uint16_t sb_sectsize; /* volume sector size (bytes) */ +- __uint16_t sb_inodesize; /* inode size (bytes) */ +- __uint8_t sb_imax_pct; /* max % of fs for inode space */ ++ uint16_t sb_sectsize; /* volume sector size (bytes) */ ++ uint16_t sb_inodesize; /* inode size (bytes) */ ++ uint8_t sb_imax_pct; /* max % of fs for inode space */ + + /* + * these don't have to match the superblock types but are placed +@@ -49,10 +49,10 @@ typedef struct fs_geometry { + /* + * fields after this point have to be checked manually in compare_sb() + */ +- __uint8_t sb_shared_vn; /* shared version number */ ++ uint8_t sb_shared_vn; /* shared version number */ + xfs_extlen_t sb_inoalignmt; /* inode chunk alignment, fsblocks */ +- __uint32_t sb_unit; /* stripe or raid unit */ +- __uint32_t sb_width; /* stripe or width unit */ ++ uint32_t sb_unit; /* stripe or raid unit */ ++ uint32_t sb_width; /* stripe or width unit */ + + /* + * these don't have to match, they track superblock properties +diff --git a/repair/attr_repair.h b/repair/attr_repair.h +index 7010e4ff..294fad44 100644 +--- a/repair/attr_repair.h ++++ b/repair/attr_repair.h +@@ -32,10 +32,10 @@ + #define ACL_WRITE 02 + #define ACL_EXECUTE 01 + +-typedef __uint16_t xfs_acl_perm_t; +-typedef __int32_t xfs_acl_type_t; +-typedef __int32_t xfs_acl_tag_t; +-typedef __int32_t xfs_acl_id_t; ++typedef uint16_t xfs_acl_perm_t; ++typedef int32_t xfs_acl_type_t; ++typedef int32_t xfs_acl_tag_t; ++typedef int32_t xfs_acl_id_t; + + /* + * "icacl" = in-core ACL. There is no equivalent in the XFS kernel code, +@@ -50,7 +50,7 @@ struct xfs_icacl_entry { + }; + + struct xfs_icacl { +- __int32_t acl_cnt; ++ int32_t acl_cnt; + struct xfs_icacl_entry acl_entry[0]; + }; + +@@ -59,14 +59,14 @@ struct xfs_icacl { + */ + #define XFS_MAC_MAX_SETS 250 + typedef struct xfs_mac_label { +- __uint8_t ml_msen_type; /* MSEN label type */ +- __uint8_t ml_mint_type; /* MINT label type */ +- __uint8_t ml_level; /* Hierarchical level */ +- __uint8_t ml_grade; /* Hierarchical grade */ +- __uint16_t ml_catcount; /* Category count */ +- __uint16_t ml_divcount; /* Division count */ ++ uint8_t ml_msen_type; /* MSEN label type */ ++ uint8_t ml_mint_type; /* MINT label type */ ++ uint8_t ml_level; /* Hierarchical level */ ++ uint8_t ml_grade; /* Hierarchical grade */ ++ uint16_t ml_catcount; /* Category count */ ++ uint16_t ml_divcount; /* Division count */ + /* Category set, then Division set */ +- __uint16_t ml_list[XFS_MAC_MAX_SETS]; ++ uint16_t ml_list[XFS_MAC_MAX_SETS]; + } xfs_mac_label_t; + + /* MSEN label type names. Choose an upper case ASCII character. */ +@@ -93,7 +93,7 @@ typedef struct xfs_mac_label { + /* + * Capabilities (IRIX) + */ +-typedef __uint64_t xfs_cap_value_t; ++typedef uint64_t xfs_cap_value_t; + + typedef struct xfs_cap_set { + xfs_cap_value_t cap_effective; /* use in capability checks */ +diff --git a/repair/avl64.c b/repair/avl64.c +index 51cd624c..8f4a1211 100644 +--- a/repair/avl64.c ++++ b/repair/avl64.c +@@ -70,8 +70,8 @@ avl64_checktree( + avl64node_t *root) + { + avl64node_t *nlast, *nnext, *np; +- __uint64_t offset = 0; +- __uint64_t end; ++ uint64_t offset = 0; ++ uint64_t end; + + nlast = nnext = root; + +@@ -583,8 +583,8 @@ attach: + avl64node_t * + avl64_findanyrange( + avl64tree_desc_t *tree, +- __uint64_t start, +- __uint64_t end, ++ uint64_t start, ++ uint64_t end, + int checklen) + { + avl64node_t *np = tree->avl_root; +@@ -655,7 +655,7 @@ avl64_findanyrange( + avl64node_t * + avl64_findrange( + avl64tree_desc_t *tree, +- __uint64_t value) ++ uint64_t value) + { + avl64node_t *np = tree->avl_root; + +@@ -682,10 +682,10 @@ avl64_findrange( + avl64node_t * + avl64_find( + avl64tree_desc_t *tree, +- __uint64_t value) ++ uint64_t value) + { + avl64node_t *np = tree->avl_root; +- __uint64_t nvalue; ++ uint64_t nvalue; + + while (np) { + nvalue = AVL_START(tree, np); +@@ -909,8 +909,8 @@ static + avl64node_t * + avl64_insert_find_growth( + avl64tree_desc_t *tree, +- __uint64_t start, /* range start at start, */ +- __uint64_t end, /* exclusive */ ++ uint64_t start, /* range start at start, */ ++ uint64_t end, /* exclusive */ + int *growthp) /* OUT */ + { + avl64node_t *root = tree->avl_root; +@@ -963,7 +963,7 @@ avl64_insert_grow( + int growth) + { + avl64node_t *nnext; +- __uint64_t start = AVL_START(tree, newnode); ++ uint64_t start = AVL_START(tree, newnode); + + if (growth == AVL_BACK) { + +@@ -1005,8 +1005,8 @@ avl64_insert( + avl64node_t *newnode) + { + avl64node_t *np; +- __uint64_t start = AVL_START(tree, newnode); +- __uint64_t end = AVL_END(tree, newnode); ++ uint64_t start = AVL_START(tree, newnode); ++ uint64_t end = AVL_END(tree, newnode); + int growth; + + ASSERT(newnode); +@@ -1159,16 +1159,16 @@ avl64ops_t avl_debug_ops = { + avl_debug_end, + } + +-static __uint64_t ++static uint64_t + avl64_debug_start(avl64node_t *node) + { +- return (__uint64_t)(struct avl_debug_node *)node->avl_start; ++ return (uint64_t)(struct avl_debug_node *)node->avl_start; + } + +-static __uint64_t ++static uint64_t + avl64_debug_end(avl64node_t *node) + { +- return (__uint64_t) ++ return (uint64_t) + ((struct avl_debug_node *)node->avl_start + + (struct avl_debug_node *)node->avl_size); + } +@@ -1304,7 +1304,7 @@ main() + avl64node_t * + avl64_findadjacent( + avl64tree_desc_t *tree, +- __uint64_t value, ++ uint64_t value, + int dir) + { + avl64node_t *np = tree->avl_root; +@@ -1378,8 +1378,8 @@ avl64_findadjacent( + void + avl64_findranges( + avl64tree_desc_t *tree, +- __uint64_t start, +- __uint64_t end, ++ uint64_t start, ++ uint64_t end, + avl64node_t **startp, + avl64node_t **endp) + { +diff --git a/repair/avl64.h b/repair/avl64.h +index fd193218..cd079a00 100644 +--- a/repair/avl64.h ++++ b/repair/avl64.h +@@ -32,8 +32,8 @@ typedef struct avl64node { + * avl-tree operations + */ + typedef struct avl64ops { +- __uint64_t (*avl_start)(avl64node_t *); +- __uint64_t (*avl_end)(avl64node_t *); ++ uint64_t (*avl_start)(avl64node_t *); ++ uint64_t (*avl_end)(avl64node_t *); + } avl64ops_t; + + /* +@@ -89,32 +89,32 @@ avl64_init_tree( + avl64node_t * + avl64_findrange( + avl64tree_desc_t *tree, +- __uint64_t value); ++ uint64_t value); + + avl64node_t * + avl64_find( + avl64tree_desc_t *tree, +- __uint64_t value); ++ uint64_t value); + + avl64node_t * + avl64_findanyrange( + avl64tree_desc_t *tree, +- __uint64_t start, +- __uint64_t end, ++ uint64_t start, ++ uint64_t end, + int checklen); + + + avl64node_t * + avl64_findadjacent( + avl64tree_desc_t *tree, +- __uint64_t value, ++ uint64_t value, + int dir); + + void + avl64_findranges( + avl64tree_desc_t *tree, +- __uint64_t start, +- __uint64_t end, ++ uint64_t start, ++ uint64_t end, + avl64node_t **startp, + avl64node_t **endp); + +diff --git a/repair/dinode.c b/repair/dinode.c +index d664f87a..da872178 100644 +--- a/repair/dinode.c ++++ b/repair/dinode.c +@@ -746,7 +746,7 @@ _("%s fork in ino %" PRIu64 " claims dup extent, " + case XR_E_FREE1: + do_warn( + _("%s fork in ino %" PRIu64 " claims free block %" PRIu64 "\n"), +- forkname, ino, (__uint64_t) b); ++ forkname, ino, (uint64_t) b); + /* fall through ... */ + case XR_E_INUSE1: /* seen by rmap */ + case XR_E_UNKNOWN: +@@ -923,7 +923,7 @@ process_btinode( + int type, + int *dirty, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + blkmap_t **blkmapp, + int whichfork, + int check_dups) +@@ -939,7 +939,7 @@ process_btinode( + int level; + int numrecs; + bmap_cursor_t cursor; +- __uint64_t magic; ++ uint64_t magic; + + dib = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork); + lino = XFS_AGINO_TO_INO(mp, agno, ino); +@@ -1098,7 +1098,7 @@ process_exinode( + int type, + int *dirty, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + blkmap_t **blkmapp, + int whichfork, + int check_dups) +@@ -1200,14 +1200,14 @@ process_symlink_extlist(xfs_mount_t *mp, xfs_ino_t lino, xfs_dinode_t *dino) + do_warn( + _("mismatch between format (%d) and size (%" PRId64 ") in symlink ino %" PRIu64 "\n"), + dino->di_format, +- (__int64_t)be64_to_cpu(dino->di_size), lino); ++ (int64_t)be64_to_cpu(dino->di_size), lino); + return 1; + } + if (dino->di_format == XFS_DINODE_FMT_LOCAL) { + do_warn( + _("mismatch between format (%d) and size (%" PRId64 ") in symlink inode %" PRIu64 "\n"), + dino->di_format, +- (__int64_t)be64_to_cpu(dino->di_size), lino); ++ (int64_t)be64_to_cpu(dino->di_size), lino); + return 1; + } + +@@ -1454,22 +1454,22 @@ _("inode %" PRIu64 " has bad inode type (IFMNT)\n"), lino); + case XR_INO_CHRDEV: + do_warn( + _("size of character device inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino, +- (__int64_t)be64_to_cpu(dino->di_size)); ++ (int64_t)be64_to_cpu(dino->di_size)); + break; + case XR_INO_BLKDEV: + do_warn( + _("size of block device inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino, +- (__int64_t)be64_to_cpu(dino->di_size)); ++ (int64_t)be64_to_cpu(dino->di_size)); + break; + case XR_INO_SOCK: + do_warn( + _("size of socket inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino, +- (__int64_t)be64_to_cpu(dino->di_size)); ++ (int64_t)be64_to_cpu(dino->di_size)); + break; + case XR_INO_FIFO: + do_warn( + _("size of fifo inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino, +- (__int64_t)be64_to_cpu(dino->di_size)); ++ (int64_t)be64_to_cpu(dino->di_size)); + break; + default: + do_warn(_("Internal error - process_misc_ino_types, " +@@ -1743,12 +1743,12 @@ _("found inode %" PRIu64 " claiming to be a real-time file\n"), lino); + break; + + case XR_INO_RTBITMAP: +- if (size != (__int64_t)mp->m_sb.sb_rbmblocks * ++ if (size != (int64_t)mp->m_sb.sb_rbmblocks * + mp->m_sb.sb_blocksize) { + do_warn( + _("realtime bitmap inode %" PRIu64 " has bad size %" PRId64 " (should be %" PRIu64 ")\n"), + lino, size, +- (__int64_t) mp->m_sb.sb_rbmblocks * ++ (int64_t) mp->m_sb.sb_rbmblocks * + mp->m_sb.sb_blocksize); + return 1; + } +@@ -1817,8 +1817,8 @@ static int + process_inode_blocks_and_extents( + xfs_dinode_t *dino, + xfs_rfsblock_t nblocks, +- __uint64_t nextents, +- __uint64_t anextents, ++ uint64_t nextents, ++ uint64_t anextents, + xfs_ino_t lino, + int *dirty) + { +@@ -1908,7 +1908,7 @@ process_inode_data_fork( + int type, + int *dirty, + xfs_rfsblock_t *totblocks, +- __uint64_t *nextents, ++ uint64_t *nextents, + blkmap_t **dblkmap, + int check_dups) + { +@@ -2017,7 +2017,7 @@ process_inode_attr_fork( + int type, + int *dirty, + xfs_rfsblock_t *atotblocks, +- __uint64_t *anextents, ++ uint64_t *anextents, + int check_dups, + int extra_attr_check, + int *retval) +@@ -2228,8 +2228,8 @@ process_dinode_int(xfs_mount_t *mp, + int di_mode; + int type; + int retval = 0; +- __uint64_t nextents; +- __uint64_t anextents; ++ uint64_t nextents; ++ uint64_t anextents; + xfs_ino_t lino; + const int is_free = 0; + const int is_used = 1; +@@ -2346,7 +2346,7 @@ _("inode identifier %llu mismatch on inode %" PRIu64 "\n"), + if (!uncertain) + do_warn( + _("bad (negative) size %" PRId64 " on inode %" PRIu64 "\n"), +- (__int64_t)be64_to_cpu(dino->di_size), ++ (int64_t)be64_to_cpu(dino->di_size), + lino); + if (verify_mode) + return 1; +diff --git a/repair/dinode.h b/repair/dinode.h +index 61d07363..39d6a72f 100644 +--- a/repair/dinode.h ++++ b/repair/dinode.h +@@ -46,8 +46,8 @@ process_bmbt_reclist(xfs_mount_t *mp, + xfs_ino_t ino, + xfs_rfsblock_t *tot, + struct blkmap **blkmapp, +- __uint64_t *first_key, +- __uint64_t *last_key, ++ uint64_t *first_key, ++ uint64_t *last_key, + int whichfork); + + int +diff --git a/repair/dir2.c b/repair/dir2.c +index e6415e49..73dff902 100644 +--- a/repair/dir2.c ++++ b/repair/dir2.c +@@ -160,7 +160,7 @@ process_sf_dir2( + int bad_sfnamelen; + int i; + int i8; +- __int64_t ino_dir_size; ++ int64_t ino_dir_size; + int ino_off; + ino_tree_node_t *irec_p; + int junkit; +diff --git a/repair/globals.h b/repair/globals.h +index 4085ccc4..c7bbe6f1 100644 +--- a/repair/globals.h ++++ b/repair/globals.h +@@ -141,7 +141,7 @@ EXTERN int inodes_per_cluster; + EXTERN unsigned int glob_agcount; + EXTERN int chunks_pblock; /* # of 64-ino chunks per allocation */ + EXTERN int max_symlink_blocks; +-EXTERN __int64_t fs_max_file_offset; ++EXTERN int64_t fs_max_file_offset; + + /* realtime info */ + +@@ -161,24 +161,24 @@ EXTERN int full_ino_ex_data;/* + + /* superblock counters */ + +-EXTERN __uint64_t sb_icount; /* allocated (made) inodes */ +-EXTERN __uint64_t sb_ifree; /* free inodes */ +-EXTERN __uint64_t sb_fdblocks; /* free data blocks */ +-EXTERN __uint64_t sb_frextents; /* free realtime extents */ ++EXTERN uint64_t sb_icount; /* allocated (made) inodes */ ++EXTERN uint64_t sb_ifree; /* free inodes */ ++EXTERN uint64_t sb_fdblocks; /* free data blocks */ ++EXTERN uint64_t sb_frextents; /* free realtime extents */ + + /* superblock geometry info */ + + EXTERN xfs_extlen_t sb_inoalignmt; +-EXTERN __uint32_t sb_unit; +-EXTERN __uint32_t sb_width; ++EXTERN uint32_t sb_unit; ++EXTERN uint32_t sb_width; + + struct aglock { + pthread_mutex_t lock __attribute__((__aligned__(64))); + }; + EXTERN struct aglock *ag_locks; + +-EXTERN int report_interval; +-EXTERN __uint64_t *prog_rpt_done; ++EXTERN int report_interval; ++EXTERN uint64_t *prog_rpt_done; + + EXTERN int ag_stride; + EXTERN int thread_count; +diff --git a/repair/incore.c b/repair/incore.c +index cb573165..a9191ae2 100644 +--- a/repair/incore.c ++++ b/repair/incore.c +@@ -179,7 +179,7 @@ get_bmap_ext( + static uint64_t *rt_bmap; + static size_t rt_bmap_size; + +-/* block records fit into __uint64_t's units */ ++/* block records fit into uint64_t's units */ + #define XR_BB_UNIT 64 /* number of bits/unit */ + #define XR_BB 4 /* bits per block record */ + #define XR_BB_NUM (XR_BB_UNIT/XR_BB) /* number of records per unit */ +@@ -203,8 +203,8 @@ set_rtbmap( + { + *(rt_bmap + bno / XR_BB_NUM) = + ((*(rt_bmap + bno / XR_BB_NUM) & +- (~((__uint64_t) XR_BB_MASK << ((bno % XR_BB_NUM) * XR_BB)))) | +- (((__uint64_t) state) << ((bno % XR_BB_NUM) * XR_BB))); ++ (~((uint64_t) XR_BB_MASK << ((bno % XR_BB_NUM) * XR_BB)))) | ++ (((uint64_t) state) << ((bno % XR_BB_NUM) * XR_BB))); + } + + static void +@@ -222,9 +222,9 @@ init_rt_bmap( + return; + + rt_bmap_size = roundup(mp->m_sb.sb_rextents / (NBBY / XR_BB), +- sizeof(__uint64_t)); ++ sizeof(uint64_t)); + +- rt_bmap = memalign(sizeof(__uint64_t), rt_bmap_size); ++ rt_bmap = memalign(sizeof(uint64_t), rt_bmap_size); + if (!rt_bmap) { + do_error( + _("couldn't allocate realtime block map, size = %" PRIu64 "\n"), +diff --git a/repair/incore.h b/repair/incore.h +index c23a3a3c..fd66084f 100644 +--- a/repair/incore.h ++++ b/repair/incore.h +@@ -257,7 +257,7 @@ typedef xfs_ino_t parent_entry_t; + struct nlink_ops; + + typedef struct parent_list { +- __uint64_t pmask; ++ uint64_t pmask; + parent_entry_t *pentries; + #ifdef DEBUG + short cnt; +@@ -265,14 +265,14 @@ typedef struct parent_list { + } parent_list_t; + + union ino_nlink { +- __uint8_t *un8; +- __uint16_t *un16; +- __uint32_t *un32; ++ uint8_t *un8; ++ uint16_t *un16; ++ uint32_t *un32; + }; + + typedef struct ino_ex_data { +- __uint64_t ino_reached; /* bit == 1 if reached */ +- __uint64_t ino_processed; /* reference checked bit mask */ ++ uint64_t ino_reached; /* bit == 1 if reached */ ++ uint64_t ino_processed; /* reference checked bit mask */ + parent_list_t *parents; + union ino_nlink counted_nlinks;/* counted nlinks in P6 */ + } ino_ex_data_t; +@@ -281,22 +281,22 @@ typedef struct ino_tree_node { + avlnode_t avl_node; + xfs_agino_t ino_startnum; /* starting inode # */ + xfs_inofree_t ir_free; /* inode free bit mask */ +- __uint64_t ir_sparse; /* sparse inode bitmask */ +- __uint64_t ino_confirmed; /* confirmed bitmask */ +- __uint64_t ino_isa_dir; /* bit == 1 if a directory */ +- __uint64_t ino_was_rl; /* bit == 1 if reflink flag set */ +- __uint64_t ino_is_rl; /* bit == 1 if reflink flag should be set */ +- __uint8_t nlink_size; ++ uint64_t ir_sparse; /* sparse inode bitmask */ ++ uint64_t ino_confirmed; /* confirmed bitmask */ ++ uint64_t ino_isa_dir; /* bit == 1 if a directory */ ++ uint64_t ino_was_rl; /* bit == 1 if reflink flag set */ ++ uint64_t ino_is_rl; /* bit == 1 if reflink flag should be set */ ++ uint8_t nlink_size; + union ino_nlink disk_nlinks; /* on-disk nlinks, set in P3 */ + union { + ino_ex_data_t *ex_data; /* phases 6,7 */ + parent_list_t *plist; /* phases 2-5 */ + } ino_un; +- __uint8_t *ftypes; /* phases 3,6 */ ++ uint8_t *ftypes; /* phases 3,6 */ + } ino_tree_node_t; + +-#define INOS_PER_IREC (sizeof(__uint64_t) * NBBY) +-#define IREC_MASK(i) ((__uint64_t)1 << (i)) ++#define INOS_PER_IREC (sizeof(uint64_t) * NBBY) ++#define IREC_MASK(i) ((uint64_t)1 << (i)) + + void add_ino_ex_data(xfs_mount_t *mp); + +@@ -543,10 +543,10 @@ static inline int inode_is_rl(struct ino_tree_node *irec, int offset) + */ + void add_inode_ref(struct ino_tree_node *irec, int offset); + void drop_inode_ref(struct ino_tree_node *irec, int offset); +-__uint32_t num_inode_references(struct ino_tree_node *irec, int offset); ++uint32_t num_inode_references(struct ino_tree_node *irec, int offset); + +-void set_inode_disk_nlinks(struct ino_tree_node *irec, int offset, __uint32_t nlinks); +-__uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int offset); ++void set_inode_disk_nlinks(struct ino_tree_node *irec, int offset, uint32_t nlinks); ++uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int offset); + + static inline int is_inode_reached(struct ino_tree_node *irec, int offset) + { +@@ -567,13 +567,13 @@ static inline void add_inode_reached(struct ino_tree_node *irec, int offset) + static inline void + set_inode_ftype(struct ino_tree_node *irec, + int ino_offset, +- __uint8_t ftype) ++ uint8_t ftype) + { + if (irec->ftypes) + irec->ftypes[ino_offset] = ftype; + } + +-static inline __uint8_t ++static inline uint8_t + get_inode_ftype( + struct ino_tree_node *irec, + int ino_offset) +@@ -606,11 +606,11 @@ typedef struct bm_level_state { + xfs_fsblock_t fsbno; + xfs_fsblock_t left_fsbno; + xfs_fsblock_t right_fsbno; +- __uint64_t first_key; +- __uint64_t last_key; ++ uint64_t first_key; ++ uint64_t last_key; + /* + int level; +- __uint64_t prev_last_key; ++ uint64_t prev_last_key; + xfs_buf_t *bp; + xfs_bmbt_block_t *block; + */ +diff --git a/repair/incore_ext.c b/repair/incore_ext.c +index 7e6786c5..0a8138a9 100644 +--- a/repair/incore_ext.c ++++ b/repair/incore_ext.c +@@ -721,13 +721,13 @@ search_rt_dup_extent(xfs_mount_t *mp, xfs_rtblock_t bno) + return(ret); + } + +-static __uint64_t ++static uint64_t + avl64_rt_ext_start(avl64node_t *node) + { + return(((rt_extent_tree_node_t *) node)->rt_startblock); + } + +-static __uint64_t ++static uint64_t + avl64_ext_end(avl64node_t *node) + { + return(((rt_extent_tree_node_t *) node)->rt_startblock + +@@ -834,7 +834,7 @@ count_extents(xfs_agnumber_t agno, avltree_desc_t *tree, int whichtree) + int + count_bno_extents_blocks(xfs_agnumber_t agno, uint *numblocks) + { +- __uint64_t nblocks; ++ uint64_t nblocks; + extent_tree_node_t *node; + int i = 0; + +diff --git a/repair/incore_ino.c b/repair/incore_ino.c +index 2ec17657..3b6b44d4 100644 +--- a/repair/incore_ino.c ++++ b/repair/incore_ino.c +@@ -38,7 +38,7 @@ static avltree_desc_t **inode_uncertain_tree_ptrs; + /* memory optimised nlink counting for all inodes */ + + static void * +-alloc_nlink_array(__uint8_t nlink_size) ++alloc_nlink_array(uint8_t nlink_size) + { + void *ptr; + +@@ -51,10 +51,10 @@ alloc_nlink_array(__uint8_t nlink_size) + static void + nlink_grow_8_to_16(ino_tree_node_t *irec) + { +- __uint16_t *new_nlinks; ++ uint16_t *new_nlinks; + int i; + +- irec->nlink_size = sizeof(__uint16_t); ++ irec->nlink_size = sizeof(uint16_t); + + new_nlinks = alloc_nlink_array(irec->nlink_size); + for (i = 0; i < XFS_INODES_PER_CHUNK; i++) +@@ -76,10 +76,10 @@ nlink_grow_8_to_16(ino_tree_node_t *irec) + static void + nlink_grow_16_to_32(ino_tree_node_t *irec) + { +- __uint32_t *new_nlinks; ++ uint32_t *new_nlinks; + int i; + +- irec->nlink_size = sizeof(__uint32_t); ++ irec->nlink_size = sizeof(uint32_t); + + new_nlinks = alloc_nlink_array(irec->nlink_size); + for (i = 0; i < XFS_INODES_PER_CHUNK; i++) +@@ -104,21 +104,21 @@ void add_inode_ref(struct ino_tree_node *irec, int ino_offset) + ASSERT(irec->ino_un.ex_data != NULL); + + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + if (irec->ino_un.ex_data->counted_nlinks.un8[ino_offset] < 0xff) { + irec->ino_un.ex_data->counted_nlinks.un8[ino_offset]++; + break; + } + nlink_grow_8_to_16(irec); + /*FALLTHRU*/ +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + if (irec->ino_un.ex_data->counted_nlinks.un16[ino_offset] < 0xffff) { + irec->ino_un.ex_data->counted_nlinks.un16[ino_offset]++; + break; + } + nlink_grow_16_to_32(irec); + /*FALLTHRU*/ +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + irec->ino_un.ex_data->counted_nlinks.un32[ino_offset]++; + break; + default: +@@ -128,20 +128,20 @@ void add_inode_ref(struct ino_tree_node *irec, int ino_offset) + + void drop_inode_ref(struct ino_tree_node *irec, int ino_offset) + { +- __uint32_t refs = 0; ++ uint32_t refs = 0; + + ASSERT(irec->ino_un.ex_data != NULL); + + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + ASSERT(irec->ino_un.ex_data->counted_nlinks.un8[ino_offset] > 0); + refs = --irec->ino_un.ex_data->counted_nlinks.un8[ino_offset]; + break; +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + ASSERT(irec->ino_un.ex_data->counted_nlinks.un16[ino_offset] > 0); + refs = --irec->ino_un.ex_data->counted_nlinks.un16[ino_offset]; + break; +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + ASSERT(irec->ino_un.ex_data->counted_nlinks.un32[ino_offset] > 0); + refs = --irec->ino_un.ex_data->counted_nlinks.un32[ino_offset]; + break; +@@ -153,16 +153,16 @@ void drop_inode_ref(struct ino_tree_node *irec, int ino_offset) + irec->ino_un.ex_data->ino_reached &= ~IREC_MASK(ino_offset); + } + +-__uint32_t num_inode_references(struct ino_tree_node *irec, int ino_offset) ++uint32_t num_inode_references(struct ino_tree_node *irec, int ino_offset) + { + ASSERT(irec->ino_un.ex_data != NULL); + + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + return irec->ino_un.ex_data->counted_nlinks.un8[ino_offset]; +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + return irec->ino_un.ex_data->counted_nlinks.un16[ino_offset]; +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + return irec->ino_un.ex_data->counted_nlinks.un32[ino_offset]; + default: + ASSERT(0); +@@ -171,24 +171,24 @@ __uint32_t num_inode_references(struct ino_tree_node *irec, int ino_offset) + } + + void set_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset, +- __uint32_t nlinks) ++ uint32_t nlinks) + { + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + if (nlinks < 0xff) { + irec->disk_nlinks.un8[ino_offset] = nlinks; + break; + } + nlink_grow_8_to_16(irec); + /*FALLTHRU*/ +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + if (nlinks < 0xffff) { + irec->disk_nlinks.un16[ino_offset] = nlinks; + break; + } + nlink_grow_16_to_32(irec); + /*FALLTHRU*/ +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + irec->disk_nlinks.un32[ino_offset] = nlinks; + break; + default: +@@ -196,14 +196,14 @@ void set_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset, + } + } + +-__uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset) ++uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset) + { + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + return irec->disk_nlinks.un8[ino_offset]; +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + return irec->disk_nlinks.un16[ino_offset]; +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + return irec->disk_nlinks.un32[ino_offset]; + default: + ASSERT(0); +@@ -211,11 +211,11 @@ __uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset) + return 0; + } + +-static __uint8_t * ++static uint8_t * + alloc_ftypes_array( + struct xfs_mount *mp) + { +- __uint8_t *ptr; ++ uint8_t *ptr; + + if (!xfs_sb_version_hasftype(&mp->m_sb)) + return NULL; +@@ -262,23 +262,23 @@ alloc_ino_node( + irec->ir_free = (xfs_inofree_t) - 1; + irec->ir_sparse = 0; + irec->ino_un.ex_data = NULL; +- irec->nlink_size = sizeof(__uint8_t); ++ irec->nlink_size = sizeof(uint8_t); + irec->disk_nlinks.un8 = alloc_nlink_array(irec->nlink_size); + irec->ftypes = alloc_ftypes_array(mp); + return irec; + } + + static void +-free_nlink_array(union ino_nlink nlinks, __uint8_t nlink_size) ++free_nlink_array(union ino_nlink nlinks, uint8_t nlink_size) + { + switch (nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + free(nlinks.un8); + break; +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + free(nlinks.un16); + break; +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + free(nlinks.un32); + break; + default: +@@ -609,7 +609,7 @@ set_inode_parent( + int i; + int cnt; + int target; +- __uint64_t bitmask; ++ uint64_t bitmask; + parent_entry_t *tmp; + + if (full_ino_ex_data) +@@ -699,7 +699,7 @@ set_inode_parent( + xfs_ino_t + get_inode_parent(ino_tree_node_t *irec, int offset) + { +- __uint64_t bitmask; ++ uint64_t bitmask; + parent_list_t *ptbl; + int i; + int target; +@@ -740,15 +740,15 @@ alloc_ex_data(ino_tree_node_t *irec) + irec->ino_un.ex_data->parents = ptbl; + + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + irec->ino_un.ex_data->counted_nlinks.un8 = + alloc_nlink_array(irec->nlink_size); + break; +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + irec->ino_un.ex_data->counted_nlinks.un16 = + alloc_nlink_array(irec->nlink_size); + break; +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + irec->ino_un.ex_data->counted_nlinks.un32 = + alloc_nlink_array(irec->nlink_size); + break; +diff --git a/repair/phase2.c b/repair/phase2.c +index c21778b8..0085732b 100644 +--- a/repair/phase2.c ++++ b/repair/phase2.c +@@ -179,7 +179,7 @@ phase2( + + bad_ino_btree = 0; + +- set_progress_msg(PROG_FMT_SCAN_AG, (__uint64_t) glob_agcount); ++ set_progress_msg(PROG_FMT_SCAN_AG, (uint64_t) glob_agcount); + + scan_ags(mp, scan_threads); + +diff --git a/repair/phase3.c b/repair/phase3.c +index 0890a27d..17b1c28d 100644 +--- a/repair/phase3.c ++++ b/repair/phase3.c +@@ -122,7 +122,7 @@ phase3( + else + do_log(_(" - scan (but don't clear) agi unlinked lists...\n")); + +- set_progress_msg(PROG_FMT_AGI_UNLINKED, (__uint64_t) glob_agcount); ++ set_progress_msg(PROG_FMT_AGI_UNLINKED, (uint64_t) glob_agcount); + + /* first clear the agi unlinked AGI list */ + if (!no_modify) { +@@ -142,7 +142,7 @@ phase3( + do_log(_( + " - process known inodes and perform inode discovery...\n")); + +- set_progress_msg(PROG_FMT_PROCESS_INO, (__uint64_t) mp->m_sb.sb_icount); ++ set_progress_msg(PROG_FMT_PROCESS_INO, (uint64_t) mp->m_sb.sb_icount); + + process_ags(mp); + +@@ -152,7 +152,7 @@ phase3( + * process newly discovered inode chunks + */ + do_log(_(" - process newly discovered inodes...\n")); +- set_progress_msg(PROG_FMT_NEW_INODES, (__uint64_t) glob_agcount); ++ set_progress_msg(PROG_FMT_NEW_INODES, (uint64_t) glob_agcount); + + counts = calloc(sizeof(*counts), mp->m_sb.sb_agcount); + if (!counts) { +diff --git a/repair/phase4.c b/repair/phase4.c +index e59464b1..cc17ec03 100644 +--- a/repair/phase4.c ++++ b/repair/phase4.c +@@ -290,7 +290,7 @@ phase4(xfs_mount_t *mp) + do_log(_("Phase 4 - check for duplicate blocks...\n")); + do_log(_(" - setting up duplicate extent list...\n")); + +- set_progress_msg(PROG_FMT_DUP_EXTENT, (__uint64_t) glob_agcount); ++ set_progress_msg(PROG_FMT_DUP_EXTENT, (uint64_t) glob_agcount); + + irec = find_inode_rec(mp, XFS_INO_TO_AGNO(mp, mp->m_sb.sb_rootino), + XFS_INO_TO_AGINO(mp, mp->m_sb.sb_rootino)); +@@ -404,7 +404,7 @@ phase4(xfs_mount_t *mp) + reset_bmaps(mp); + + do_log(_(" - check for inodes claiming duplicate blocks...\n")); +- set_progress_msg(PROG_FMT_DUP_BLOCKS, (__uint64_t) mp->m_sb.sb_icount); ++ set_progress_msg(PROG_FMT_DUP_BLOCKS, (uint64_t) mp->m_sb.sb_icount); + + /* + * ok, now process the inodes -- signal 2-pass check per inode. +diff --git a/repair/phase5.c b/repair/phase5.c +index 0b833f13..21dce67a 100644 +--- a/repair/phase5.c ++++ b/repair/phase5.c +@@ -86,9 +86,9 @@ struct agi_stat { + xfs_agino_t freecount; + }; + +-static __uint64_t *sb_icount_ag; /* allocated inodes per ag */ +-static __uint64_t *sb_ifree_ag; /* free inodes per ag */ +-static __uint64_t *sb_fdblocks_ag; /* free data blocks per ag */ ++static uint64_t *sb_icount_ag; /* allocated inodes per ag */ ++static uint64_t *sb_ifree_ag; /* free inodes per ag */ ++static uint64_t *sb_fdblocks_ag; /* free data blocks per ag */ + + static int + mk_incore_fstree(xfs_mount_t *mp, xfs_agnumber_t agno) +@@ -886,10 +886,10 @@ build_freespace_tree(xfs_mount_t *mp, xfs_agnumber_t agno, + */ + static void + init_ino_cursor(xfs_mount_t *mp, xfs_agnumber_t agno, bt_status_t *btree_curs, +- __uint64_t *num_inos, __uint64_t *num_free_inos, int finobt) ++ uint64_t *num_inos, uint64_t *num_free_inos, int finobt) + { +- __uint64_t ninos; +- __uint64_t nfinos; ++ uint64_t ninos; ++ uint64_t nfinos; + int rec_nfinos; + int rec_ninos; + ino_tree_node_t *ino_rec; +@@ -2193,10 +2193,10 @@ phase5_func( + xfs_agnumber_t agno, + struct xfs_slab *lost_fsb) + { +- __uint64_t num_inos; +- __uint64_t num_free_inos; +- __uint64_t finobt_num_inos; +- __uint64_t finobt_num_free_inos; ++ uint64_t num_inos; ++ uint64_t num_free_inos; ++ uint64_t finobt_num_inos; ++ uint64_t finobt_num_free_inos; + bt_status_t bno_btree_curs; + bt_status_t bcnt_btree_curs; + bt_status_t ino_btree_curs; +@@ -2471,7 +2471,7 @@ phase5(xfs_mount_t *mp) + int error; + + do_log(_("Phase 5 - rebuild AG headers and trees...\n")); +- set_progress_msg(PROG_FMT_REBUILD_AG, (__uint64_t )glob_agcount); ++ set_progress_msg(PROG_FMT_REBUILD_AG, (uint64_t)glob_agcount); + + #ifdef XR_BLD_FREE_TRACE + fprintf(stderr, "inobt level 1, maxrec = %d, minrec = %d\n", +@@ -2497,15 +2497,15 @@ phase5(xfs_mount_t *mp) + keep_fsinos(mp); + + /* allocate per ag counters */ +- sb_icount_ag = calloc(mp->m_sb.sb_agcount, sizeof(__uint64_t)); ++ sb_icount_ag = calloc(mp->m_sb.sb_agcount, sizeof(uint64_t)); + if (sb_icount_ag == NULL) + do_error(_("cannot alloc sb_icount_ag buffers\n")); + +- sb_ifree_ag = calloc(mp->m_sb.sb_agcount, sizeof(__uint64_t)); ++ sb_ifree_ag = calloc(mp->m_sb.sb_agcount, sizeof(uint64_t)); + if (sb_ifree_ag == NULL) + do_error(_("cannot alloc sb_ifree_ag buffers\n")); + +- sb_fdblocks_ag = calloc(mp->m_sb.sb_agcount, sizeof(__uint64_t)); ++ sb_fdblocks_ag = calloc(mp->m_sb.sb_agcount, sizeof(uint64_t)); + if (sb_fdblocks_ag == NULL) + do_error(_("cannot alloc sb_fdblocks_ag buffers\n")); + +diff --git a/repair/phase6.c b/repair/phase6.c +index 08636dcf..373b1a5b 100644 +--- a/repair/phase6.c ++++ b/repair/phase6.c +@@ -82,7 +82,7 @@ typedef struct dir_hash_ent { + struct dir_hash_ent *nextbyhash; /* next in name bucket */ + struct dir_hash_ent *nextbyorder; /* next in order added */ + xfs_dahash_t hashval; /* hash value of name */ +- __uint32_t address; /* offset of data entry */ ++ uint32_t address; /* offset of data entry */ + xfs_ino_t inum; /* inode num of entry */ + short junkit; /* name starts with / */ + short seen; /* have seen leaf entry */ +@@ -170,11 +170,11 @@ static int + dir_hash_add( + xfs_mount_t *mp, + dir_hash_tab_t *hashtab, +- __uint32_t addr, ++ uint32_t addr, + xfs_ino_t inum, + int namelen, + unsigned char *name, +- __uint8_t ftype) ++ uint8_t ftype) + { + xfs_dahash_t hash = 0; + int byaddr; +@@ -357,7 +357,7 @@ static void + dir_hash_update_ftype( + dir_hash_tab_t *hashtab, + xfs_dir2_dataptr_t addr, +- __uint8_t ftype) ++ uint8_t ftype) + { + int i; + dir_hash_ent_t *p; +@@ -1791,8 +1791,8 @@ longform_dir2_entry_check_data( + + /* validate ftype field if supported */ + if (xfs_sb_version_hasftype(&mp->m_sb)) { +- __uint8_t dir_ftype; +- __uint8_t ino_ftype; ++ uint8_t dir_ftype; ++ uint8_t ino_ftype; + + dir_ftype = M_DIROPS(mp)->data_get_ftype(dep); + ino_ftype = get_inode_ftype(irec, ino_offset); +@@ -2703,8 +2703,8 @@ _("entry \"%s\" (ino %" PRIu64 ") in dir %" PRIu64 " is a duplicate name"), + + /* validate ftype field if supported */ + if (xfs_sb_version_hasftype(&mp->m_sb)) { +- __uint8_t dir_ftype; +- __uint8_t ino_ftype; ++ uint8_t dir_ftype; ++ uint8_t ino_ftype; + + dir_ftype = M_DIROPS(mp)->sf_get_ftype(sfep); + ino_ftype = get_inode_ftype(irec, ino_offset); +diff --git a/repair/phase7.c b/repair/phase7.c +index 8bce117d..4ffb81a8 100644 +--- a/repair/phase7.c ++++ b/repair/phase7.c +@@ -32,7 +32,7 @@ static void + update_inode_nlinks( + xfs_mount_t *mp, + xfs_ino_t ino, +- __uint32_t nlinks) ++ uint32_t nlinks) + { + xfs_trans_t *tp; + xfs_inode_t *ip; +@@ -104,7 +104,7 @@ do_link_updates( + { + ino_tree_node_t *irec; + int j; +- __uint32_t nrefs; ++ uint32_t nrefs; + + for (irec = findfirst_inode_rec(agno); irec; + irec = next_ino_rec(irec)) { +@@ -143,7 +143,7 @@ phase7( + else + do_log(_("Phase 7 - verify link counts...\n")); + +- set_progress_msg(PROGRESS_FMT_CORR_LINK, (__uint64_t) glob_agcount); ++ set_progress_msg(PROGRESS_FMT_CORR_LINK, (uint64_t) glob_agcount); + + create_work_queue(&wq, mp, scan_threads); + +diff --git a/repair/progress.c b/repair/progress.c +index 2a09b239..99d2658c 100644 +--- a/repair/progress.c ++++ b/repair/progress.c +@@ -85,8 +85,8 @@ pthread_t report_thread; + typedef struct msg_block_s { + pthread_mutex_t mutex; + progress_rpt_t *format; +- __uint64_t *done; +- __uint64_t *total; ++ uint64_t *done; ++ uint64_t *total; + int count; + int interval; + } msg_block_t; +@@ -96,14 +96,14 @@ typedef struct phase_times_s { + time_t start; + time_t end; + time_t duration; +- __uint64_t item_counts[4]; ++ uint64_t item_counts[4]; + } phase_times_t; + static phase_times_t phase_times[8]; + + static void *progress_rpt_thread(void *); + static int current_phase; + static int running; +-static __uint64_t prog_rpt_total; ++static uint64_t prog_rpt_total; + + void + init_progress_rpt (void) +@@ -113,11 +113,11 @@ init_progress_rpt (void) + * allocate the done vector + */ + +- if ((prog_rpt_done = (__uint64_t *) +- malloc(sizeof(__uint64_t)*glob_agcount)) == NULL ) { ++ if ((prog_rpt_done = (uint64_t *) ++ malloc(sizeof(uint64_t)*glob_agcount)) == NULL) { + do_error(_("cannot malloc pointer to done vector\n")); + } +- bzero(prog_rpt_done, sizeof(__uint64_t)*glob_agcount); ++ bzero(prog_rpt_done, sizeof(uint64_t)*glob_agcount); + + /* + * Setup comm block, start the thread +@@ -165,10 +165,10 @@ progress_rpt_thread (void *p) + timer_t timerid; + struct itimerspec timespec; + char *msgbuf; +- __uint64_t *donep; +- __uint64_t sum; ++ uint64_t *donep; ++ uint64_t sum; + msg_block_t *msgp = (msg_block_t *)p; +- __uint64_t percent; ++ uint64_t percent; + + /* It's possible to get here very early w/ no progress msg set */ + if (!msgp->format) +@@ -286,7 +286,7 @@ progress_rpt_thread (void *p) + } + + int +-set_progress_msg (int report, __uint64_t total) ++set_progress_msg(int report, uint64_t total) + { + + if (!ag_stride) +@@ -300,7 +300,7 @@ set_progress_msg (int report, __uint64_t total) + + /* reset all the accumulative totals */ + if (prog_rpt_done) +- bzero(prog_rpt_done, sizeof(__uint64_t)*glob_agcount); ++ bzero(prog_rpt_done, sizeof(uint64_t)*glob_agcount); + + if (pthread_mutex_unlock(&global_msgs.mutex)) + do_error(_("set_progress_msg: cannot unlock progress mutex\n")); +@@ -308,14 +308,14 @@ set_progress_msg (int report, __uint64_t total) + return (0); + } + +-__uint64_t ++uint64_t + print_final_rpt(void) + { + int i; + struct tm *tmp; + time_t now; +- __uint64_t *donep; +- __uint64_t sum; ++ uint64_t *donep; ++ uint64_t sum; + msg_block_t *msgp = &global_msgs; + char msgbuf[DURATION_BUF_SIZE]; + +diff --git a/repair/progress.h b/repair/progress.h +index 33db8344..51526483 100644 +--- a/repair/progress.h ++++ b/repair/progress.h +@@ -32,8 +32,8 @@ + extern void init_progress_rpt(void); + extern void stop_progress_rpt(void); + extern void summary_report(void); +-extern int set_progress_msg(int report, __uint64_t total); +-extern __uint64_t print_final_rpt(void); ++extern int set_progress_msg(int report, uint64_t total); ++extern uint64_t print_final_rpt(void); + extern char *timestamp(int end, int phase, char *buf); + extern char *duration(int val, char *buf); + extern int do_parallel; +diff --git a/repair/rmap.c b/repair/rmap.c +index ab6e5839..01d6f0fc 100644 +--- a/repair/rmap.c ++++ b/repair/rmap.c +@@ -343,7 +343,7 @@ err: + + static int + find_first_zero_bit( +- __uint64_t mask) ++ uint64_t mask) + { + int n; + int b = 0; +@@ -356,7 +356,7 @@ find_first_zero_bit( + + static int + popcnt( +- __uint64_t mask) ++ uint64_t mask) + { + int n; + int b = 0; +@@ -1064,14 +1064,14 @@ err: + * Compare the key fields of two rmap records -- positive if key1 > key2, + * negative if key1 < key2, and zero if equal. + */ +-__int64_t ++int64_t + rmap_diffkeys( + struct xfs_rmap_irec *kp1, + struct xfs_rmap_irec *kp2) + { + __u64 oa; + __u64 ob; +- __int64_t d; ++ int64_t d; + struct xfs_rmap_irec tmp; + + tmp = *kp1; +@@ -1081,7 +1081,7 @@ rmap_diffkeys( + tmp.rm_flags &= ~XFS_RMAP_REC_FLAGS; + ob = libxfs_rmap_irec_offset_pack(&tmp); + +- d = (__int64_t)kp1->rm_startblock - kp2->rm_startblock; ++ d = (int64_t)kp1->rm_startblock - kp2->rm_startblock; + if (d) + return d; + +@@ -1192,10 +1192,10 @@ fix_inode_reflink_flags( + { + struct ino_tree_node *irec; + int bit; +- __uint64_t was; +- __uint64_t is; +- __uint64_t diff; +- __uint64_t mask; ++ uint64_t was; ++ uint64_t is; ++ uint64_t diff; ++ uint64_t mask; + int error = 0; + xfs_agino_t agino; + +diff --git a/repair/rmap.h b/repair/rmap.h +index 752ece82..1616ab7d 100644 +--- a/repair/rmap.h ++++ b/repair/rmap.h +@@ -44,7 +44,7 @@ extern int rmap_init_cursor(xfs_agnumber_t, struct xfs_slab_cursor **); + extern void rmap_avoid_check(void); + extern int rmaps_verify_btree(struct xfs_mount *, xfs_agnumber_t); + +-extern __int64_t rmap_diffkeys(struct xfs_rmap_irec *kp1, ++extern int64_t rmap_diffkeys(struct xfs_rmap_irec *kp1, + struct xfs_rmap_irec *kp2); + extern void rmap_high_key_from_rec(struct xfs_rmap_irec *rec, + struct xfs_rmap_irec *key); +diff --git a/repair/sb.c b/repair/sb.c +index 77e51546..acc92839 100644 +--- a/repair/sb.c ++++ b/repair/sb.c +@@ -40,7 +40,7 @@ copy_sb(xfs_sb_t *source, xfs_sb_t *dest) + xfs_ino_t uquotino; + xfs_ino_t gquotino; + xfs_ino_t pquotino; +- __uint16_t versionnum; ++ uint16_t versionnum; + + rootino = dest->sb_rootino; + rbmino = dest->sb_rbmino; +@@ -106,8 +106,8 @@ verify_sb_blocksize(xfs_sb_t *sb) + static int + __find_secondary_sb( + xfs_sb_t *rsb, +- __uint64_t start, +- __uint64_t skip) ++ uint64_t start, ++ uint64_t skip) + { + xfs_off_t off; + xfs_sb_t *sb; +@@ -187,13 +187,13 @@ __find_secondary_sb( + + static int + guess_default_geometry( +- __uint64_t *agsize, +- __uint64_t *agcount, ++ uint64_t *agsize, ++ uint64_t *agcount, + libxfs_init_t *x) + { + struct fs_topology ft; + int blocklog; +- __uint64_t dblocks; ++ uint64_t dblocks; + int multidisk; + + memset(&ft, 0, sizeof(ft)); +@@ -216,9 +216,9 @@ int + find_secondary_sb(xfs_sb_t *rsb) + { + int retval = 0; +- __uint64_t agcount; +- __uint64_t agsize; +- __uint64_t skip; ++ uint64_t agcount; ++ uint64_t agsize; ++ uint64_t skip; + int blocklog; + + /* +@@ -229,7 +229,7 @@ find_secondary_sb(xfs_sb_t *rsb) + do_warn(_("\nattempting to find secondary superblock...\n")); + + if (verify_sb_blocksize(rsb) == 0) { +- skip = (__uint64_t)rsb->sb_agblocks * rsb->sb_blocksize; ++ skip = (uint64_t)rsb->sb_agblocks * rsb->sb_blocksize; + if (skip >= XFS_AG_MIN_BYTES && skip <= XFS_AG_MAX_BYTES) + retval = __find_secondary_sb(rsb, skip, skip); + } +@@ -343,7 +343,7 @@ sb_validate_ino_align(struct xfs_sb *sb) + int + verify_sb(char *sb_buf, xfs_sb_t *sb, int is_primary_sb) + { +- __uint32_t bsize; ++ uint32_t bsize; + int i; + int ret; + +@@ -399,7 +399,7 @@ verify_sb(char *sb_buf, xfs_sb_t *sb, int is_primary_sb) + sb->sb_dblocks < XFS_MIN_DBLOCKS(sb)) + return(XR_BAD_FS_SIZE_DATA); + +- if (sb->sb_agblklog != (__uint8_t)libxfs_log2_roundup(sb->sb_agblocks)) ++ if (sb->sb_agblklog != (uint8_t)libxfs_log2_roundup(sb->sb_agblocks)) + return(XR_BAD_FS_SIZE_DATA); + + if (sb->sb_inodesize < XFS_DINODE_MIN_SIZE || +diff --git a/repair/scan.c b/repair/scan.c +index b9ef4dc3..447611ac 100644 +--- a/repair/scan.c ++++ b/repair/scan.c +@@ -42,13 +42,13 @@ struct aghdr_cnts { + xfs_agnumber_t agno; + xfs_extlen_t agffreeblks; + xfs_extlen_t agflongest; +- __uint64_t agfbtreeblks; +- __uint32_t agicount; +- __uint32_t agifreecount; +- __uint64_t fdblocks; +- __uint64_t usedblocks; +- __uint64_t ifreecount; +- __uint32_t fibtfreecount; ++ uint64_t agfbtreeblks; ++ uint32_t agicount; ++ uint32_t agifreecount; ++ uint64_t fdblocks; ++ uint64_t usedblocks; ++ uint64_t ifreecount; ++ uint32_t fibtfreecount; + }; + + void +@@ -70,10 +70,10 @@ scan_sbtree( + xfs_agnumber_t agno, + int suspect, + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv), + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv, + const struct xfs_buf_ops *ops) + { +@@ -110,23 +110,23 @@ scan_lbtree( + xfs_fsblock_t bno, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + blkmap_t **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, + int *dirty, +- __uint64_t magic), ++ uint64_t magic), + int type, + int whichfork, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + blkmap_t **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, +- __uint64_t magic, ++ uint64_t magic, + const struct xfs_buf_ops *ops) + { + xfs_buf_t *bp; +@@ -179,13 +179,13 @@ scan_bmapbt( + xfs_fsblock_t bno, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + blkmap_t **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, + int *dirty, +- __uint64_t magic) ++ uint64_t magic) + { + int i; + int err; +@@ -548,7 +548,7 @@ scan_allocbt( + xfs_agnumber_t agno, + int suspect, + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv) + { + struct aghdr_cnts *agcnts = priv; +@@ -930,7 +930,7 @@ scan_rmapbt( + xfs_agnumber_t agno, + int suspect, + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv) + { + const char *name = "rmap"; +@@ -1233,7 +1233,7 @@ scan_refcbt( + xfs_agnumber_t agno, + int suspect, + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv) + { + const char *name = "refcount"; +@@ -1939,7 +1939,7 @@ scan_inobt( + xfs_agnumber_t agno, + int suspect, + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv) + { + struct aghdr_cnts *agcnts = priv; +@@ -2176,7 +2176,7 @@ validate_agf( + struct aghdr_cnts *agcnts) + { + xfs_agblock_t bno; +- __uint32_t magic; ++ uint32_t magic; + + bno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNO]); + if (bno != 0 && verify_agbno(mp, agno, bno)) { +@@ -2274,7 +2274,7 @@ validate_agi( + { + xfs_agblock_t bno; + int i; +- __uint32_t magic; ++ uint32_t magic; + + bno = be32_to_cpu(agi->agi_root); + if (bno != 0 && verify_agbno(mp, agno, bno)) { +@@ -2499,10 +2499,10 @@ scan_ags( + int scan_threads) + { + struct aghdr_cnts *agcnts; +- __uint64_t fdblocks = 0; +- __uint64_t icount = 0; +- __uint64_t ifreecount = 0; +- __uint64_t usedblocks = 0; ++ uint64_t fdblocks = 0; ++ uint64_t icount = 0; ++ uint64_t ifreecount = 0; ++ uint64_t usedblocks = 0; + xfs_agnumber_t i; + work_queue_t wq; + +diff --git a/repair/scan.h b/repair/scan.h +index ea8c0bf2..9bbe1e69 100644 +--- a/repair/scan.h ++++ b/repair/scan.h +@@ -30,23 +30,23 @@ int scan_lbtree( + xfs_fsblock_t bno, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + struct blkmap **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, + int *dirty, +- __uint64_t magic), ++ uint64_t magic), + int type, + int whichfork, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + struct blkmap **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, +- __uint64_t magic, ++ uint64_t magic, + const struct xfs_buf_ops *ops); + + int scan_bmapbt( +@@ -57,13 +57,13 @@ int scan_bmapbt( + xfs_fsblock_t bno, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + struct blkmap **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, + int *dirty, +- __uint64_t magic); ++ uint64_t magic); + + void + scan_ags( +-- +2.14.1 + |