On Wed, May 17, 2017 at 11:32:06PM -0700, Christoph Hellwig wrote:
> On Wed, May 17, 2017 at 06:31:38PM -0700, Darrick J. Wong wrote:
> > 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:
>
> While I'm fine with this in general, didn't we run into xfstests error
> last time this was attempted? Or was that just the move from the *64
> libc calls to the non64 ones and asking for LFS support?
I /think/ that was the 64bit LFS support change that did that. I ran
xfstests over the weekend and didn't see any new breakage resulting from
the type change. I also tried nastier things like __uint kernel + uint
xfsprogs and that didn't pop anything else up either.
--D
>
> > 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@xxxxxxxxxx>
> > ---
> > 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 | 4 -
> > db/io.h | 8 +
> > 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 +
> > libxfs/xfs_alloc_btree.c | 20 ++-
> > libxfs/xfs_attr_remote.c | 8 +
> > libxfs/xfs_attr_sf.h | 10 +-
> > libxfs/xfs_bit.h | 24 ++--
> > libxfs/xfs_bmap_btree.c | 8 +
> > libxfs/xfs_btree.c | 22 ++--
> > libxfs/xfs_btree.h | 18 ++-
> > libxfs/xfs_cksum.h | 16 +--
> > libxfs/xfs_da_btree.c | 2
> > libxfs/xfs_da_btree.h | 8 +
> > libxfs/xfs_da_format.c | 28 ++---
> > libxfs/xfs_da_format.h | 64 +++++------
> > libxfs/xfs_dir2.h | 8 +
> > libxfs/xfs_dir2_leaf.c | 12 +-
> > libxfs/xfs_dir2_priv.h | 2
> > libxfs/xfs_dir2_sf.c | 2
> > libxfs/xfs_format.h | 112 +++++++++----------
> > libxfs/xfs_fs.h | 12 +-
> > libxfs/xfs_ialloc.c | 6 +
> > libxfs/xfs_ialloc_btree.c | 4 -
> > libxfs/xfs_inode_buf.c | 2
> > libxfs/xfs_inode_buf.h | 28 ++---
> > libxfs/xfs_log_format.h | 256 ++++++++++++++++++++++---------------------
> > libxfs/xfs_quota_defs.h | 4 -
> > libxfs/xfs_refcount_btree.c | 8 +
> > libxfs/xfs_rmap.c | 8 +
> > libxfs/xfs_rmap.h | 8 +
> > libxfs/xfs_rmap_btree.c | 30 +++--
> > libxfs/xfs_rtbitmap.c | 2
> > libxfs/xfs_sb.c | 4 -
> > libxfs/xfs_types.h | 46 ++++----
> > 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 | 16 +--
> > 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 +-
> > 111 files changed, 982 insertions(+), 982 deletions(-)
> >
> > diff --git a/copy/xfs_copy.c b/copy/xfs_copy.c
> > index a7da824..33e05df 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 2737068..53c6e42 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 e26ac67..6f56953 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 d82559c..2ef358f 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 24872bf..f5ebf68 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 80ba24c..9fd71f4 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 4a357ce..5ecd687 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 8e618a2..81ba63a 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 a337abe..fa4f962 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 877200b..5620764 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 1968dd5..2a2197a 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 },
> > @@ -197,7 +197,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 },
> > @@ -212,7 +212,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,
> > @@ -293,7 +293,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 },
> > @@ -333,15 +333,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 },
> > @@ -354,34 +354,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 fd7e7f4..261a31e 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 8005e45..d224f0c 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 8b7a41e..7538ee0 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 9918a51..f93c8af 100644
> > --- a/db/io.c
> > +++ b/db/io.c
> > @@ -536,7 +536,7 @@ write_cur(void)
> > void
> > set_cur(
> > const typ_t *t,
> > - __int64_t d,
> > + int64_t d,
> > int c,
> > int ring_flag,
> > bbmap_t *bbmap)
> > @@ -544,7 +544,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 = t ? t->bops : NULL;
> >
> > if (iocur_sp < 0) {
> > diff --git a/db/io.h b/db/io.h
> > index b415b82..0b3cba4 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,9 +57,9 @@ 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 *t, __int64_t d, int c, int ring_add,
> > +extern void set_cur(const struct typ *t, int64_t d, int c, int ring_add,
> > bbmap_t *bbmap);
> > extern void ring_add(void);
> > extern void set_iocur_type(const struct typ *t);
> > diff --git a/db/metadump.c b/db/metadump.c
> > index 66952f6..06da7c6 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 @@ process_inode(
> > return success;
> > }
> >
> > -static __uint32_t inodes_copied = 0;
> > +static uint32_t inodes_copied = 0;
> >
> > static int
> > copy_inode_chunk(
> > diff --git a/db/sb.c b/db/sb.c
> > index 8e7722c..f19248d 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 517b75f..d4846a3 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 7bbd576..51031c4 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 fb318b8..f52ed0a 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 6916e65..1db3f4f 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 e8d2ffc..6806380 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 181d25c..4726915 100644
> > --- a/include/linux.h
> > +++ b/include/linux.h
> > @@ -140,7 +140,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;
> > @@ -152,9 +152,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 12cd43e..186cadb 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 fb6b542..8766024 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 7582676..0d09862 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 f4be51b..90d6cb1 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_reserved;
> > + uint8_t mb_blocklog;
> > + uint8_t mb_reserved;
> > /* followed by an array of xfs_daddr_t */
> > } xfs_metablock_t;
> >
> > diff --git a/include/xfs_mount.h b/include/xfs_mount.h
> > index 5ff24eb..5b323bb 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 236ed22..00127b3 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 e52f5d8..821061b 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 8b0276a..f66dd1b 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 74507e8..16d2c35 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 4667d1f..d7bca14 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 85e0d15..27a7600 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 32fcb3e..0f14aec 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 0b4c489..a3912e7 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 69f04ad..0bace3e 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 7e93f60..466b442 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 eef9c36..3f0257f 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 6c8a192..43b4f1d 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 dcfca39..7938e31 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/libxfs/xfs_alloc_btree.c b/libxfs/xfs_alloc_btree.c
> > index e11d89a..8e77e6e 100644
> > --- a/libxfs/xfs_alloc_btree.c
> > +++ b/libxfs/xfs_alloc_btree.c
> > @@ -251,7 +251,7 @@ xfs_allocbt_init_ptr_from_cur(
> > ptr->s = agf->agf_roots[cur->bc_btnum];
> > }
> >
> > -STATIC __int64_t
> > +STATIC int64_t
> > xfs_bnobt_key_diff(
> > struct xfs_btree_cur *cur,
> > union xfs_btree_key *key)
> > @@ -259,42 +259,42 @@ xfs_bnobt_key_diff(
> > xfs_alloc_rec_incore_t *rec = &cur->bc_rec.a;
> > xfs_alloc_key_t *kp = &key->alloc;
> >
> > - return (__int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;
> > + return (int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;
> > }
> >
> > -STATIC __int64_t
> > +STATIC int64_t
> > xfs_cntbt_key_diff(
> > struct xfs_btree_cur *cur,
> > union xfs_btree_key *key)
> > {
> > xfs_alloc_rec_incore_t *rec = &cur->bc_rec.a;
> > xfs_alloc_key_t *kp = &key->alloc;
> > - __int64_t diff;
> > + int64_t diff;
> >
> > - diff = (__int64_t)be32_to_cpu(kp->ar_blockcount) - rec->ar_blockcount;
> > + diff = (int64_t)be32_to_cpu(kp->ar_blockcount) - rec->ar_blockcount;
> > if (diff)
> > return diff;
> >
> > - return (__int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;
> > + return (int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;
> > }
> >
> > -STATIC __int64_t
> > +STATIC int64_t
> > xfs_bnobt_diff_two_keys(
> > struct xfs_btree_cur *cur,
> > union xfs_btree_key *k1,
> > union xfs_btree_key *k2)
> > {
> > - return (__int64_t)be32_to_cpu(k1->alloc.ar_startblock) -
> > + return (int64_t)be32_to_cpu(k1->alloc.ar_startblock) -
> > be32_to_cpu(k2->alloc.ar_startblock);
> > }
> >
> > -STATIC __int64_t
> > +STATIC int64_t
> > xfs_cntbt_diff_two_keys(
> > struct xfs_btree_cur *cur,
> > union xfs_btree_key *k1,
> > union xfs_btree_key *k2)
> > {
> > - __int64_t diff;
> > + int64_t diff;
> >
> > diff = be32_to_cpu(k1->alloc.ar_blockcount) -
> > be32_to_cpu(k2->alloc.ar_blockcount);
> > diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c
> > index abe1705..1f25e36 100644
> > --- a/libxfs/xfs_attr_remote.c
> > +++ b/libxfs/xfs_attr_remote.c
> > @@ -248,7 +248,7 @@ xfs_attr_rmtval_copyout(
> > xfs_ino_t ino,
> > int *offset,
> > int *valuelen,
> > - __uint8_t **dst)
> > + uint8_t **dst)
> > {
> > char *src = bp->b_addr;
> > xfs_daddr_t bno = bp->b_bn;
> > @@ -296,7 +296,7 @@ xfs_attr_rmtval_copyin(
> > xfs_ino_t ino,
> > int *offset,
> > int *valuelen,
> > - __uint8_t **src)
> > + uint8_t **src)
> > {
> > char *dst = bp->b_addr;
> > xfs_daddr_t bno = bp->b_bn;
> > @@ -350,7 +350,7 @@ xfs_attr_rmtval_get(
> > struct xfs_mount *mp = args->dp->i_mount;
> > struct xfs_buf *bp;
> > xfs_dablk_t lblkno = args->rmtblkno;
> > - __uint8_t *dst = args->value;
> > + uint8_t *dst = args->value;
> > int valuelen;
> > int nmap;
> > int error;
> > @@ -416,7 +416,7 @@ xfs_attr_rmtval_set(
> > struct xfs_bmbt_irec map;
> > xfs_dablk_t lblkno;
> > xfs_fileoff_t lfileoff = 0;
> > - __uint8_t *src = args->value;
> > + uint8_t *src = args->value;
> > int blkcnt;
> > int valuelen;
> > int nmap;
> > diff --git a/libxfs/xfs_attr_sf.h b/libxfs/xfs_attr_sf.h
> > index 90928bb..afd684a 100644
> > --- a/libxfs/xfs_attr_sf.h
> > +++ b/libxfs/xfs_attr_sf.h
> > @@ -31,10 +31,10 @@ typedef struct xfs_attr_sf_entry xfs_attr_sf_entry_t;
> > * We generate this then sort it, attr_list() must return things in hash-order.
> > */
> > typedef struct xfs_attr_sf_sort {
> > - __uint8_t entno; /* entry number in original list */
> > - __uint8_t namelen; /* length of name value (no null) */
> > - __uint8_t valuelen; /* length of value */
> > - __uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */
> > + uint8_t entno; /* entry number in original list */
> > + uint8_t namelen; /* length of name value (no null) */
> > + uint8_t valuelen; /* length of value */
> > + uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */
> > xfs_dahash_t hash; /* this entry's hash value */
> > unsigned char *name; /* name value, pointer into buffer */
> > } xfs_attr_sf_sort_t;
> > @@ -42,7 +42,7 @@ typedef struct xfs_attr_sf_sort {
> > #define XFS_ATTR_SF_ENTSIZE_BYNAME(nlen,vlen) /* space name/value uses */ \
> > (((int)sizeof(xfs_attr_sf_entry_t)-1 + (nlen)+(vlen)))
> > #define XFS_ATTR_SF_ENTSIZE_MAX /* max space for name&value */ \
> > - ((1 << (NBBY*(int)sizeof(__uint8_t))) - 1)
> > + ((1 << (NBBY*(int)sizeof(uint8_t))) - 1)
> > #define XFS_ATTR_SF_ENTSIZE(sfep) /* space an entry uses */ \
> > ((int)sizeof(xfs_attr_sf_entry_t)-1 + (sfep)->namelen+(sfep)->valuelen)
> > #define XFS_ATTR_SF_NEXTENTRY(sfep) /* next entry in struct */ \
> > diff --git a/libxfs/xfs_bit.h b/libxfs/xfs_bit.h
> > index e1649c0..61c6b20 100644
> > --- a/libxfs/xfs_bit.h
> > +++ b/libxfs/xfs_bit.h
> > @@ -25,47 +25,47 @@
> > /*
> > * masks with n high/low bits set, 64-bit values
> > */
> > -static inline __uint64_t xfs_mask64hi(int n)
> > +static inline uint64_t xfs_mask64hi(int n)
> > {
> > - return (__uint64_t)-1 << (64 - (n));
> > + return (uint64_t)-1 << (64 - (n));
> > }
> > -static inline __uint32_t xfs_mask32lo(int n)
> > +static inline uint32_t xfs_mask32lo(int n)
> > {
> > - return ((__uint32_t)1 << (n)) - 1;
> > + return ((uint32_t)1 << (n)) - 1;
> > }
> > -static inline __uint64_t xfs_mask64lo(int n)
> > +static inline uint64_t xfs_mask64lo(int n)
> > {
> > - return ((__uint64_t)1 << (n)) - 1;
> > + return ((uint64_t)1 << (n)) - 1;
> > }
> >
> > /* Get high bit set out of 32-bit argument, -1 if none set */
> > -static inline int xfs_highbit32(__uint32_t v)
> > +static inline int xfs_highbit32(uint32_t v)
> > {
> > return fls(v) - 1;
> > }
> >
> > /* Get high bit set out of 64-bit argument, -1 if none set */
> > -static inline int xfs_highbit64(__uint64_t v)
> > +static inline int xfs_highbit64(uint64_t v)
> > {
> > return fls64(v) - 1;
> > }
> >
> > /* Get low bit set out of 32-bit argument, -1 if none set */
> > -static inline int xfs_lowbit32(__uint32_t v)
> > +static inline int xfs_lowbit32(uint32_t v)
> > {
> > return ffs(v) - 1;
> > }
> >
> > /* Get low bit set out of 64-bit argument, -1 if none set */
> > -static inline int xfs_lowbit64(__uint64_t v)
> > +static inline int xfs_lowbit64(uint64_t v)
> > {
> > - __uint32_t w = (__uint32_t)v;
> > + uint32_t w = (uint32_t)v;
> > int n = 0;
> >
> > if (w) { /* lower bits */
> > n = ffs(w);
> > } else { /* upper bits */
> > - w = (__uint32_t)(v >> 32);
> > + w = (uint32_t)(v >> 32);
> > if (w) {
> > n = ffs(w);
> > if (n)
> > diff --git a/libxfs/xfs_bmap_btree.c b/libxfs/xfs_bmap_btree.c
> > index c48cbec..9ee40d8 100644
> > --- a/libxfs/xfs_bmap_btree.c
> > +++ b/libxfs/xfs_bmap_btree.c
> > @@ -91,8 +91,8 @@ xfs_bmdr_to_bmbt(
> > */
> > STATIC void
> > __xfs_bmbt_get_all(
> > - __uint64_t l0,
> > - __uint64_t l1,
> > + uint64_t l0,
> > + uint64_t l1,
> > xfs_bmbt_irec_t *s)
> > {
> > int ext_flag;
> > @@ -585,12 +585,12 @@ xfs_bmbt_init_ptr_from_cur(
> > ptr->l = 0;
> > }
> >
> > -STATIC __int64_t
> > +STATIC int64_t
> > xfs_bmbt_key_diff(
> > struct xfs_btree_cur *cur,
> > union xfs_btree_key *key)
> > {
> > - return (__int64_t)be64_to_cpu(key->bmbt.br_startoff) -
> > + return (int64_t)be64_to_cpu(key->bmbt.br_startoff) -
> > cur->bc_rec.b.br_startoff;
> > }
> >
> > diff --git a/libxfs/xfs_btree.c b/libxfs/xfs_btree.c
> > index a9e1fa8..646f2bf 100644
> > --- a/libxfs/xfs_btree.c
> > +++ b/libxfs/xfs_btree.c
> > @@ -39,7 +39,7 @@ kmem_zone_t *xfs_btree_cur_zone;
> > /*
> > * Btree magic numbers.
> > */
> > -static const __uint32_t xfs_magics[2][XFS_BTNUM_MAX] = {
> > +static const uint32_t xfs_magics[2][XFS_BTNUM_MAX] = {
> > { XFS_ABTB_MAGIC, XFS_ABTC_MAGIC, 0, XFS_BMAP_MAGIC, XFS_IBT_MAGIC,
> > XFS_FIBT_MAGIC, 0 },
> > { XFS_ABTB_CRC_MAGIC, XFS_ABTC_CRC_MAGIC, XFS_RMAP_CRC_MAGIC,
> > @@ -47,12 +47,12 @@ static const __uint32_t xfs_magics[2][XFS_BTNUM_MAX] = {
> > XFS_REFC_CRC_MAGIC }
> > };
> >
> > -__uint32_t
> > +uint32_t
> > xfs_btree_magic(
> > int crc,
> > xfs_btnum_t btnum)
> > {
> > - __uint32_t magic = xfs_magics[crc][btnum];
> > + uint32_t magic = xfs_magics[crc][btnum];
> >
> > /* Ensure we asked for crc for crc-only magics. */
> > ASSERT(magic != 0);
> > @@ -774,14 +774,14 @@ xfs_btree_lastrec(
> > */
> > void
> > xfs_btree_offsets(
> > - __int64_t fields, /* bitmask of fields */
> > + int64_t fields, /* bitmask of fields */
> > const short *offsets, /* table of field offsets */
> > int nbits, /* number of bits to inspect */
> > int *first, /* output: first byte offset */
> > int *last) /* output: last byte offset */
> > {
> > int i; /* current bit number */
> > - __int64_t imask; /* mask for current bit number */
> > + int64_t imask; /* mask for current bit number */
> >
> > ASSERT(fields != 0);
> > /*
> > @@ -1842,7 +1842,7 @@ xfs_btree_lookup(
> > int *stat) /* success/failure */
> > {
> > struct xfs_btree_block *block; /* current btree block */
> > - __int64_t diff; /* difference for the current key */
> > + int64_t diff; /* difference for the current key */
> > int error; /* error return value */
> > int keyno; /* current key number */
> > int level; /* level in the btree */
> > @@ -4435,7 +4435,7 @@ xfs_btree_visit_blocks(
> > * recovery completion writes the changes to disk.
> > */
> > struct xfs_btree_block_change_owner_info {
> > - __uint64_t new_owner;
> > + uint64_t new_owner;
> > struct list_head *buffer_list;
> > };
> >
> > @@ -4481,7 +4481,7 @@ xfs_btree_block_change_owner(
> > int
> > xfs_btree_change_owner(
> > struct xfs_btree_cur *cur,
> > - __uint64_t new_owner,
> > + uint64_t new_owner,
> > struct list_head *buffer_list)
> > {
> > struct xfs_btree_block_change_owner_info bbcoi;
> > @@ -4585,7 +4585,7 @@ xfs_btree_simple_query_range(
> > {
> > union xfs_btree_rec *recp;
> > union xfs_btree_key rec_key;
> > - __int64_t diff;
> > + int64_t diff;
> > int stat;
> > bool firstrec = true;
> > int error;
> > @@ -4682,8 +4682,8 @@ xfs_btree_overlapped_query_range(
> > union xfs_btree_key *hkp;
> > union xfs_btree_rec *recp;
> > struct xfs_btree_block *block;
> > - __int64_t ldiff;
> > - __int64_t hdiff;
> > + int64_t ldiff;
> > + int64_t hdiff;
> > int level;
> > struct xfs_buf *bp;
> > int i;
> > diff --git a/libxfs/xfs_btree.h b/libxfs/xfs_btree.h
> > index 05cf35b..3c1fed2 100644
> > --- a/libxfs/xfs_btree.h
> > +++ b/libxfs/xfs_btree.h
> > @@ -76,7 +76,7 @@ union xfs_btree_rec {
> > #define XFS_BTNUM_RMAP ((xfs_btnum_t)XFS_BTNUM_RMAPi)
> > #define XFS_BTNUM_REFC ((xfs_btnum_t)XFS_BTNUM_REFCi)
> >
> > -__uint32_t xfs_btree_magic(int crc, xfs_btnum_t btnum);
> > +uint32_t xfs_btree_magic(int crc, xfs_btnum_t btnum);
> >
> > /*
> > * For logging record fields.
> > @@ -150,14 +150,14 @@ struct xfs_btree_ops {
> > union xfs_btree_rec *rec);
> >
> > /* difference between key value and cursor value */
> > - __int64_t (*key_diff)(struct xfs_btree_cur *cur,
> > + int64_t (*key_diff)(struct xfs_btree_cur *cur,
> > union xfs_btree_key *key);
> >
> > /*
> > * Difference between key2 and key1 -- positive if key1 > key2,
> > * negative if key1 < key2, and zero if equal.
> > */
> > - __int64_t (*diff_two_keys)(struct xfs_btree_cur *cur,
> > + int64_t (*diff_two_keys)(struct xfs_btree_cur *cur,
> > union xfs_btree_key *key1,
> > union xfs_btree_key *key2);
> >
> > @@ -213,11 +213,11 @@ typedef struct xfs_btree_cur
> > union xfs_btree_irec bc_rec; /* current insert/search record value */
> > struct xfs_buf *bc_bufs[XFS_BTREE_MAXLEVELS]; /* buf ptr per level */
> > int bc_ptrs[XFS_BTREE_MAXLEVELS]; /* key/record # */
> > - __uint8_t bc_ra[XFS_BTREE_MAXLEVELS]; /* readahead bits */
> > + uint8_t bc_ra[XFS_BTREE_MAXLEVELS]; /* readahead bits */
> > #define XFS_BTCUR_LEFTRA 1 /* left sibling has been read-ahead */
> > #define XFS_BTCUR_RIGHTRA 2 /* right sibling has been read-ahead */
> > - __uint8_t bc_nlevels; /* number of levels in the tree */
> > - __uint8_t bc_blocklog; /* log2(blocksize) of btree blocks */
> > + uint8_t bc_nlevels; /* number of levels in the tree */
> > + uint8_t bc_blocklog; /* log2(blocksize) of btree blocks */
> > xfs_btnum_t bc_btnum; /* identifies which btree type */
> > int bc_statoff; /* offset of btre stats array */
> > union {
> > @@ -330,7 +330,7 @@ xfs_btree_islastblock(
> > */
> > void
> > xfs_btree_offsets(
> > - __int64_t fields, /* bitmask of fields */
> > + int64_t fields, /* bitmask of fields */
> > const short *offsets,/* table of field offsets */
> > int nbits, /* number of bits to inspect */
> > int *first, /* output: first byte offset */
> > @@ -408,7 +408,7 @@ int xfs_btree_new_iroot(struct xfs_btree_cur *, int *, int *);
> > int xfs_btree_insert(struct xfs_btree_cur *, int *);
> > int xfs_btree_delete(struct xfs_btree_cur *, int *);
> > int xfs_btree_get_rec(struct xfs_btree_cur *, union xfs_btree_rec **, int *);
> > -int xfs_btree_change_owner(struct xfs_btree_cur *cur, __uint64_t new_owner,
> > +int xfs_btree_change_owner(struct xfs_btree_cur *cur, uint64_t new_owner,
> > struct list_head *buffer_list);
> >
> > /*
> > @@ -434,7 +434,7 @@ static inline int xfs_btree_get_numrecs(struct xfs_btree_block *block)
> > }
> >
> > static inline void xfs_btree_set_numrecs(struct xfs_btree_block *block,
> > - __uint16_t numrecs)
> > + uint16_t numrecs)
> > {
> > block->bb_numrecs = cpu_to_be16(numrecs);
> > }
> > diff --git a/libxfs/xfs_cksum.h b/libxfs/xfs_cksum.h
> > index a416c7c..8211f48 100644
> > --- a/libxfs/xfs_cksum.h
> > +++ b/libxfs/xfs_cksum.h
> > @@ -1,7 +1,7 @@
> > #ifndef _XFS_CKSUM_H
> > #define _XFS_CKSUM_H 1
> >
> > -#define XFS_CRC_SEED (~(__uint32_t)0)
> > +#define XFS_CRC_SEED (~(uint32_t)0)
> >
> > /*
> > * Calculate the intermediate checksum for a buffer that has the CRC field
> > @@ -9,11 +9,11 @@
> > * cksum_offset parameter. We do not modify the buffer during verification,
> > * hence we have to split the CRC calculation across the cksum_offset.
> > */
> > -static inline __uint32_t
> > +static inline uint32_t
> > xfs_start_cksum_safe(char *buffer, size_t length, unsigned long cksum_offset)
> > {
> > - __uint32_t zero = 0;
> > - __uint32_t crc;
> > + uint32_t zero = 0;
> > + uint32_t crc;
> >
> > /* Calculate CRC up to the checksum. */
> > crc = crc32c(XFS_CRC_SEED, buffer, cksum_offset);
> > @@ -30,7 +30,7 @@ xfs_start_cksum_safe(char *buffer, size_t length, unsigned long cksum_offset)
> > * Fast CRC method where the buffer is modified. Callers must have exclusive
> > * access to the buffer while the calculation takes place.
> > */
> > -static inline __uint32_t
> > +static inline uint32_t
> > xfs_start_cksum_update(char *buffer, size_t length, unsigned long cksum_offset)
> > {
> > /* zero the CRC field */
> > @@ -48,7 +48,7 @@ xfs_start_cksum_update(char *buffer, size_t length, unsigned long cksum_offset)
> > * so that it is consistent on disk.
> > */
> > static inline __le32
> > -xfs_end_cksum(__uint32_t crc)
> > +xfs_end_cksum(uint32_t crc)
> > {
> > return ~cpu_to_le32(crc);
> > }
> > @@ -62,7 +62,7 @@ xfs_end_cksum(__uint32_t crc)
> > static inline void
> > xfs_update_cksum(char *buffer, size_t length, unsigned long cksum_offset)
> > {
> > - __uint32_t crc = xfs_start_cksum_update(buffer, length, cksum_offset);
> > + uint32_t crc = xfs_start_cksum_update(buffer, length, cksum_offset);
> >
> > *(__le32 *)(buffer + cksum_offset) = xfs_end_cksum(crc);
> > }
> > @@ -73,7 +73,7 @@ xfs_update_cksum(char *buffer, size_t length, unsigned long cksum_offset)
> > static inline int
> > xfs_verify_cksum(char *buffer, size_t length, unsigned long cksum_offset)
> > {
> > - __uint32_t crc = xfs_start_cksum_safe(buffer, length, cksum_offset);
> > + uint32_t crc = xfs_start_cksum_safe(buffer, length, cksum_offset);
> >
> > return *(__le32 *)(buffer + cksum_offset) == xfs_end_cksum(crc);
> > }
> > diff --git a/libxfs/xfs_da_btree.c b/libxfs/xfs_da_btree.c
> > index bc12f58..08447be 100644
> > --- a/libxfs/xfs_da_btree.c
> > +++ b/libxfs/xfs_da_btree.c
> > @@ -1947,7 +1947,7 @@ xfs_da3_path_shift(
> > * This is implemented with some source-level loop unrolling.
> > */
> > xfs_dahash_t
> > -xfs_da_hashname(const __uint8_t *name, int namelen)
> > +xfs_da_hashname(const uint8_t *name, int namelen)
> > {
> > xfs_dahash_t hash;
> >
> > diff --git a/libxfs/xfs_da_btree.h b/libxfs/xfs_da_btree.h
> > index 4e29cb6..ae6de17 100644
> > --- a/libxfs/xfs_da_btree.h
> > +++ b/libxfs/xfs_da_btree.h
> > @@ -60,10 +60,10 @@ enum xfs_dacmp {
> > */
> > typedef struct xfs_da_args {
> > struct xfs_da_geometry *geo; /* da block geometry */
> > - const __uint8_t *name; /* string (maybe not NULL terminated) */
> > + const uint8_t *name; /* string (maybe not NULL terminated) */
> > int namelen; /* length of string (maybe no NULL) */
> > - __uint8_t filetype; /* filetype of inode for directories */
> > - __uint8_t *value; /* set of bytes (maybe contain NULLs) */
> > + uint8_t filetype; /* filetype of inode for directories */
> > + uint8_t *value; /* set of bytes (maybe contain NULLs) */
> > int valuelen; /* length of value */
> > int flags; /* argument flags (eg: ATTR_NOCREATE) */
> > xfs_dahash_t hashval; /* hash value of name */
> > @@ -207,7 +207,7 @@ int xfs_da_reada_buf(struct xfs_inode *dp, xfs_dablk_t bno,
> > int xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,
> > struct xfs_buf *dead_buf);
> >
> > -uint xfs_da_hashname(const __uint8_t *name_string, int name_length);
> > +uint xfs_da_hashname(const uint8_t *name_string, int name_length);
> > enum xfs_dacmp xfs_da_compname(struct xfs_da_args *args,
> > const unsigned char *name, int len);
> >
> > diff --git a/libxfs/xfs_da_format.c b/libxfs/xfs_da_format.c
> > index 2b732b3..f30004f 100644
> > --- a/libxfs/xfs_da_format.c
> > +++ b/libxfs/xfs_da_format.c
> > @@ -49,7 +49,7 @@ xfs_dir3_sf_entsize(
> > struct xfs_dir2_sf_hdr *hdr,
> > int len)
> > {
> > - return xfs_dir2_sf_entsize(hdr, len) + sizeof(__uint8_t);
> > + return xfs_dir2_sf_entsize(hdr, len) + sizeof(uint8_t);
> > }
> >
> > static struct xfs_dir2_sf_entry *
> > @@ -77,7 +77,7 @@ xfs_dir3_sf_nextentry(
> > * not necessary. For non-filetype enable directories, the type is always
> > * unknown and we never store the value.
> > */
> > -static __uint8_t
> > +static uint8_t
> > xfs_dir2_sfe_get_ftype(
> > struct xfs_dir2_sf_entry *sfep)
> > {
> > @@ -87,16 +87,16 @@ xfs_dir2_sfe_get_ftype(
> > static void
> > xfs_dir2_sfe_put_ftype(
> > struct xfs_dir2_sf_entry *sfep,
> > - __uint8_t ftype)
> > + uint8_t ftype)
> > {
> > ASSERT(ftype < XFS_DIR3_FT_MAX);
> > }
> >
> > -static __uint8_t
> > +static uint8_t
> > xfs_dir3_sfe_get_ftype(
> > struct xfs_dir2_sf_entry *sfep)
> > {
> > - __uint8_t ftype;
> > + uint8_t ftype;
> >
> > ftype = sfep->name[sfep->namelen];
> > if (ftype >= XFS_DIR3_FT_MAX)
> > @@ -107,7 +107,7 @@ xfs_dir3_sfe_get_ftype(
> > static void
> > xfs_dir3_sfe_put_ftype(
> > struct xfs_dir2_sf_entry *sfep,
> > - __uint8_t ftype)
> > + uint8_t ftype)
> > {
> > ASSERT(ftype < XFS_DIR3_FT_MAX);
> >
> > @@ -124,7 +124,7 @@ xfs_dir3_sfe_put_ftype(
> > static xfs_ino_t
> > xfs_dir2_sf_get_ino(
> > struct xfs_dir2_sf_hdr *hdr,
> > - __uint8_t *from)
> > + uint8_t *from)
> > {
> > if (hdr->i8count)
> > return get_unaligned_be64(from) & 0x00ffffffffffffffULL;
> > @@ -135,7 +135,7 @@ xfs_dir2_sf_get_ino(
> > static void
> > xfs_dir2_sf_put_ino(
> > struct xfs_dir2_sf_hdr *hdr,
> > - __uint8_t *to,
> > + uint8_t *to,
> > xfs_ino_t ino)
> > {
> > ASSERT((ino & 0xff00000000000000ULL) == 0);
> > @@ -225,7 +225,7 @@ xfs_dir3_sfe_put_ino(
> >
> > #define XFS_DIR3_DATA_ENTSIZE(n) \
> > round_up((offsetof(struct xfs_dir2_data_entry, name[0]) + (n) + \
> > - sizeof(xfs_dir2_data_off_t) + sizeof(__uint8_t)), \
> > + sizeof(xfs_dir2_data_off_t) + sizeof(uint8_t)), \
> > XFS_DIR2_DATA_ALIGN)
> >
> > static int
> > @@ -242,7 +242,7 @@ xfs_dir3_data_entsize(
> > return XFS_DIR3_DATA_ENTSIZE(n);
> > }
> >
> > -static __uint8_t
> > +static uint8_t
> > xfs_dir2_data_get_ftype(
> > struct xfs_dir2_data_entry *dep)
> > {
> > @@ -252,16 +252,16 @@ xfs_dir2_data_get_ftype(
> > static void
> > xfs_dir2_data_put_ftype(
> > struct xfs_dir2_data_entry *dep,
> > - __uint8_t ftype)
> > + uint8_t ftype)
> > {
> > ASSERT(ftype < XFS_DIR3_FT_MAX);
> > }
> >
> > -static __uint8_t
> > +static uint8_t
> > xfs_dir3_data_get_ftype(
> > struct xfs_dir2_data_entry *dep)
> > {
> > - __uint8_t ftype = dep->name[dep->namelen];
> > + uint8_t ftype = dep->name[dep->namelen];
> >
> > if (ftype >= XFS_DIR3_FT_MAX)
> > return XFS_DIR3_FT_UNKNOWN;
> > @@ -271,7 +271,7 @@ xfs_dir3_data_get_ftype(
> > static void
> > xfs_dir3_data_put_ftype(
> > struct xfs_dir2_data_entry *dep,
> > - __uint8_t type)
> > + uint8_t type)
> > {
> > ASSERT(type < XFS_DIR3_FT_MAX);
> > ASSERT(dep->namelen != 0);
> > diff --git a/libxfs/xfs_da_format.h b/libxfs/xfs_da_format.h
> > index 9a492a9..3771edc 100644
> > --- a/libxfs/xfs_da_format.h
> > +++ b/libxfs/xfs_da_format.h
> > @@ -111,11 +111,11 @@ struct xfs_da3_intnode {
> > * appropriate.
> > */
> > struct xfs_da3_icnode_hdr {
> > - __uint32_t forw;
> > - __uint32_t back;
> > - __uint16_t magic;
> > - __uint16_t count;
> > - __uint16_t level;
> > + uint32_t forw;
> > + uint32_t back;
> > + uint16_t magic;
> > + uint16_t count;
> > + uint16_t level;
> > };
> >
> > /*
> > @@ -187,14 +187,14 @@ struct xfs_da3_icnode_hdr {
> > /*
> > * Byte offset in data block and shortform entry.
> > */
> > -typedef __uint16_t xfs_dir2_data_off_t;
> > +typedef uint16_t xfs_dir2_data_off_t;
> > #define NULLDATAOFF 0xffffU
> > typedef uint xfs_dir2_data_aoff_t; /* argument form */
> >
> > /*
> > * Offset in data space of a data entry.
> > */
> > -typedef __uint32_t xfs_dir2_dataptr_t;
> > +typedef uint32_t xfs_dir2_dataptr_t;
> > #define XFS_DIR2_MAX_DATAPTR ((xfs_dir2_dataptr_t)0xffffffff)
> > #define XFS_DIR2_NULL_DATAPTR ((xfs_dir2_dataptr_t)0)
> >
> > @@ -206,7 +206,7 @@ typedef xfs_off_t xfs_dir2_off_t;
> > /*
> > * Directory block number (logical dirblk in file)
> > */
> > -typedef __uint32_t xfs_dir2_db_t;
> > +typedef uint32_t xfs_dir2_db_t;
> >
> > #define XFS_INO32_SIZE 4
> > #define XFS_INO64_SIZE 8
> > @@ -226,9 +226,9 @@ typedef __uint32_t xfs_dir2_db_t;
> > * over them.
> > */
> > typedef struct xfs_dir2_sf_hdr {
> > - __uint8_t count; /* count of entries */
> > - __uint8_t i8count; /* count of 8-byte inode #s */
> > - __uint8_t parent[8]; /* parent dir inode number */
> > + uint8_t count; /* count of entries */
> > + uint8_t i8count; /* count of 8-byte inode #s */
> > + uint8_t parent[8]; /* parent dir inode number */
> > } __packed xfs_dir2_sf_hdr_t;
> >
> > typedef struct xfs_dir2_sf_entry {
> > @@ -447,11 +447,11 @@ struct xfs_dir3_leaf_hdr {
> > };
> >
> > struct xfs_dir3_icleaf_hdr {
> > - __uint32_t forw;
> > - __uint32_t back;
> > - __uint16_t magic;
> > - __uint16_t count;
> > - __uint16_t stale;
> > + uint32_t forw;
> > + uint32_t back;
> > + uint16_t magic;
> > + uint16_t count;
> > + uint16_t stale;
> > };
> >
> > /*
> > @@ -538,10 +538,10 @@ struct xfs_dir3_free {
> > * xfs_dir3_free_hdr_from_disk/xfs_dir3_free_hdr_to_disk.
> > */
> > struct xfs_dir3_icfree_hdr {
> > - __uint32_t magic;
> > - __uint32_t firstdb;
> > - __uint32_t nvalid;
> > - __uint32_t nused;
> > + uint32_t magic;
> > + uint32_t firstdb;
> > + uint32_t nvalid;
> > + uint32_t nused;
> >
> > };
> >
> > @@ -632,10 +632,10 @@ typedef struct xfs_attr_shortform {
> > __u8 padding;
> > } hdr;
> > struct xfs_attr_sf_entry {
> > - __uint8_t namelen; /* actual length of name (no NULL) */
> > - __uint8_t valuelen; /* actual length of value (no NULL) */
> > - __uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */
> > - __uint8_t nameval[1]; /* name & value bytes concatenated */
> > + uint8_t namelen; /* actual length of name (no NULL) */
> > + uint8_t valuelen; /* actual length of value (no NULL) */
> > + uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */
> > + uint8_t nameval[1]; /* name & value bytes concatenated */
> > } list[1]; /* variable sized array */
> > } xfs_attr_shortform_t;
> >
> > @@ -725,22 +725,22 @@ struct xfs_attr3_leafblock {
> > * incore, neutral version of the attribute leaf header
> > */
> > struct xfs_attr3_icleaf_hdr {
> > - __uint32_t forw;
> > - __uint32_t back;
> > - __uint16_t magic;
> > - __uint16_t count;
> > - __uint16_t usedbytes;
> > + uint32_t forw;
> > + uint32_t back;
> > + uint16_t magic;
> > + uint16_t count;
> > + uint16_t usedbytes;
> > /*
> > * firstused is 32-bit here instead of 16-bit like the on-disk variant
> > * to support maximum fsb size of 64k without overflow issues throughout
> > * the attr code. Instead, the overflow condition is handled on
> > * conversion to/from disk.
> > */
> > - __uint32_t firstused;
> > + uint32_t firstused;
> > __u8 holes;
> > struct {
> > - __uint16_t base;
> > - __uint16_t size;
> > + uint16_t base;
> > + uint16_t size;
> > } freemap[XFS_ATTR_LEAF_MAPSIZE];
> > };
> >
> > diff --git a/libxfs/xfs_dir2.h b/libxfs/xfs_dir2.h
> > index d6e6d9d..21c8f8b 100644
> > --- a/libxfs/xfs_dir2.h
> > +++ b/libxfs/xfs_dir2.h
> > @@ -47,9 +47,9 @@ struct xfs_dir_ops {
> > struct xfs_dir2_sf_entry *
> > (*sf_nextentry)(struct xfs_dir2_sf_hdr *hdr,
> > struct xfs_dir2_sf_entry *sfep);
> > - __uint8_t (*sf_get_ftype)(struct xfs_dir2_sf_entry *sfep);
> > + uint8_t (*sf_get_ftype)(struct xfs_dir2_sf_entry *sfep);
> > void (*sf_put_ftype)(struct xfs_dir2_sf_entry *sfep,
> > - __uint8_t ftype);
> > + uint8_t ftype);
> > xfs_ino_t (*sf_get_ino)(struct xfs_dir2_sf_hdr *hdr,
> > struct xfs_dir2_sf_entry *sfep);
> > void (*sf_put_ino)(struct xfs_dir2_sf_hdr *hdr,
> > @@ -60,9 +60,9 @@ struct xfs_dir_ops {
> > xfs_ino_t ino);
> >
> > int (*data_entsize)(int len);
> > - __uint8_t (*data_get_ftype)(struct xfs_dir2_data_entry *dep);
> > + uint8_t (*data_get_ftype)(struct xfs_dir2_data_entry *dep);
> > void (*data_put_ftype)(struct xfs_dir2_data_entry *dep,
> > - __uint8_t ftype);
> > + uint8_t ftype);
> > __be16 * (*data_entry_tag_p)(struct xfs_dir2_data_entry *dep);
> > struct xfs_dir2_data_free *
> > (*data_bestfree_p)(struct xfs_dir2_data_hdr *hdr);
> > diff --git a/libxfs/xfs_dir2_leaf.c b/libxfs/xfs_dir2_leaf.c
> > index f80d91f..40a35b8 100644
> > --- a/libxfs/xfs_dir2_leaf.c
> > +++ b/libxfs/xfs_dir2_leaf.c
> > @@ -142,7 +142,7 @@ xfs_dir3_leaf_check_int(
> > static bool
> > xfs_dir3_leaf_verify(
> > struct xfs_buf *bp,
> > - __uint16_t magic)
> > + uint16_t magic)
> > {
> > struct xfs_mount *mp = bp->b_target->bt_mount;
> > struct xfs_dir2_leaf *leaf = bp->b_addr;
> > @@ -151,7 +151,7 @@ xfs_dir3_leaf_verify(
> >
> > if (xfs_sb_version_hascrc(&mp->m_sb)) {
> > struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
> > - __uint16_t magic3;
> > + uint16_t magic3;
> >
> > magic3 = (magic == XFS_DIR2_LEAF1_MAGIC) ? XFS_DIR3_LEAF1_MAGIC
> > : XFS_DIR3_LEAFN_MAGIC;
> > @@ -175,7 +175,7 @@ xfs_dir3_leaf_verify(
> > static void
> > __read_verify(
> > struct xfs_buf *bp,
> > - __uint16_t magic)
> > + uint16_t magic)
> > {
> > struct xfs_mount *mp = bp->b_target->bt_mount;
> >
> > @@ -192,7 +192,7 @@ __read_verify(
> > static void
> > __write_verify(
> > struct xfs_buf *bp,
> > - __uint16_t magic)
> > + uint16_t magic)
> > {
> > struct xfs_mount *mp = bp->b_target->bt_mount;
> > struct xfs_buf_log_item *bip = bp->b_fspriv;
> > @@ -296,7 +296,7 @@ xfs_dir3_leaf_init(
> > struct xfs_trans *tp,
> > struct xfs_buf *bp,
> > xfs_ino_t owner,
> > - __uint16_t type)
> > + uint16_t type)
> > {
> > struct xfs_dir2_leaf *leaf = bp->b_addr;
> >
> > @@ -340,7 +340,7 @@ xfs_dir3_leaf_get_buf(
> > xfs_da_args_t *args,
> > xfs_dir2_db_t bno,
> > struct xfs_buf **bpp,
> > - __uint16_t magic)
> > + uint16_t magic)
> > {
> > struct xfs_inode *dp = args->dp;
> > struct xfs_trans *tp = args->trans;
> > diff --git a/libxfs/xfs_dir2_priv.h b/libxfs/xfs_dir2_priv.h
> > index 39f8604..011df4d 100644
> > --- a/libxfs/xfs_dir2_priv.h
> > +++ b/libxfs/xfs_dir2_priv.h
> > @@ -69,7 +69,7 @@ extern void xfs_dir3_leaf_compact_x1(struct xfs_dir3_icleaf_hdr *leafhdr,
> > struct xfs_dir2_leaf_entry *ents, int *indexp,
> > int *lowstalep, int *highstalep, int *lowlogp, int *highlogp);
> > extern int xfs_dir3_leaf_get_buf(struct xfs_da_args *args, xfs_dir2_db_t bno,
> > - struct xfs_buf **bpp, __uint16_t magic);
> > + struct xfs_buf **bpp, uint16_t magic);
> > extern void xfs_dir3_leaf_log_ents(struct xfs_da_args *args,
> > struct xfs_buf *bp, int first, int last);
> > extern void xfs_dir3_leaf_log_header(struct xfs_da_args *args,
> > diff --git a/libxfs/xfs_dir2_sf.c b/libxfs/xfs_dir2_sf.c
> > index 195f816..fdbe5e1 100644
> > --- a/libxfs/xfs_dir2_sf.c
> > +++ b/libxfs/xfs_dir2_sf.c
> > @@ -645,7 +645,7 @@ xfs_dir2_sf_verify(
> > int offset;
> > int size;
> > int error;
> > - __uint8_t filetype;
> > + uint8_t filetype;
> >
> > ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_LOCAL);
> > /*
> > diff --git a/libxfs/xfs_format.h b/libxfs/xfs_format.h
> > index 4c3ed1f..a53f035 100644
> > --- a/libxfs/xfs_format.h
> > +++ b/libxfs/xfs_format.h
> > @@ -103,8 +103,8 @@ struct xfs_ifork;
> > * Must be padded to 64 bit alignment.
> > */
> > typedef struct xfs_sb {
> > - __uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */
> > - __uint32_t sb_blocksize; /* logical block size, bytes */
> > + uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */
> > + uint32_t sb_blocksize; /* logical block size, bytes */
> > xfs_rfsblock_t sb_dblocks; /* number of data blocks */
> > xfs_rfsblock_t sb_rblocks; /* number of realtime blocks */
> > xfs_rtblock_t sb_rextents; /* number of realtime extents */
> > @@ -118,45 +118,45 @@ typedef struct xfs_sb {
> > xfs_agnumber_t sb_agcount; /* number of allocation groups */
> > xfs_extlen_t sb_rbmblocks; /* number of rt bitmap blocks */
> > xfs_extlen_t sb_logblocks; /* number of log blocks */
> > - __uint16_t sb_versionnum; /* header version == XFS_SB_VERSION */
> > - __uint16_t sb_sectsize; /* volume sector size, bytes */
> > - __uint16_t sb_inodesize; /* inode size, bytes */
> > - __uint16_t sb_inopblock; /* inodes per block */
> > + uint16_t sb_versionnum; /* header version == XFS_SB_VERSION */
> > + uint16_t sb_sectsize; /* volume sector size, bytes */
> > + uint16_t sb_inodesize; /* inode size, bytes */
> > + uint16_t sb_inopblock; /* inodes per block */
> > char sb_fname[12]; /* file system name */
> > - __uint8_t sb_blocklog; /* log2 of sb_blocksize */
> > - __uint8_t sb_sectlog; /* log2 of sb_sectsize */
> > - __uint8_t sb_inodelog; /* log2 of sb_inodesize */
> > - __uint8_t sb_inopblog; /* log2 of sb_inopblock */
> > - __uint8_t sb_agblklog; /* log2 of sb_agblocks (rounded up) */
> > - __uint8_t sb_rextslog; /* log2 of sb_rextents */
> > - __uint8_t sb_inprogress; /* mkfs is in progress, don't mount */
> > - __uint8_t sb_imax_pct; /* max % of fs for inode space */
> > + uint8_t sb_blocklog; /* log2 of sb_blocksize */
> > + uint8_t sb_sectlog; /* log2 of sb_sectsize */
> > + uint8_t sb_inodelog; /* log2 of sb_inodesize */
> > + uint8_t sb_inopblog; /* log2 of sb_inopblock */
> > + uint8_t sb_agblklog; /* log2 of sb_agblocks (rounded up) */
> > + uint8_t sb_rextslog; /* log2 of sb_rextents */
> > + uint8_t sb_inprogress; /* mkfs is in progress, don't mount */
> > + uint8_t sb_imax_pct; /* max % of fs for inode space */
> > /* statistics */
> > /*
> > * These fields must remain contiguous. If you really
> > * want to change their layout, make sure you fix the
> > * code in xfs_trans_apply_sb_deltas().
> > */
> > - __uint64_t sb_icount; /* allocated inodes */
> > - __uint64_t sb_ifree; /* free inodes */
> > - __uint64_t sb_fdblocks; /* free data blocks */
> > - __uint64_t sb_frextents; /* free realtime extents */
> > + uint64_t sb_icount; /* allocated inodes */
> > + uint64_t sb_ifree; /* free inodes */
> > + uint64_t sb_fdblocks; /* free data blocks */
> > + uint64_t sb_frextents; /* free realtime extents */
> > /*
> > * End contiguous fields.
> > */
> > xfs_ino_t sb_uquotino; /* user quota inode */
> > xfs_ino_t sb_gquotino; /* group quota inode */
> > - __uint16_t sb_qflags; /* quota flags */
> > - __uint8_t sb_flags; /* misc. flags */
> > - __uint8_t sb_shared_vn; /* shared version number */
> > + uint16_t sb_qflags; /* quota flags */
> > + uint8_t sb_flags; /* misc. flags */
> > + 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 raid width */
> > - __uint8_t sb_dirblklog; /* log2 of dir block size (fsbs) */
> > - __uint8_t sb_logsectlog; /* log2 of the log sector size */
> > - __uint16_t sb_logsectsize; /* sector size for the log, bytes */
> > - __uint32_t sb_logsunit; /* stripe unit size for the log */
> > - __uint32_t sb_features2; /* additional feature bits */
> > + uint32_t sb_unit; /* stripe or raid unit */
> > + uint32_t sb_width; /* stripe or raid width */
> > + uint8_t sb_dirblklog; /* log2 of dir block size (fsbs) */
> > + uint8_t sb_logsectlog; /* log2 of the log sector size */
> > + uint16_t sb_logsectsize; /* sector size for the log, bytes */
> > + uint32_t sb_logsunit; /* stripe unit size for the log */
> > + uint32_t sb_features2; /* additional feature bits */
> >
> > /*
> > * bad features2 field as a result of failing to pad the sb structure to
> > @@ -167,17 +167,17 @@ typedef struct xfs_sb {
> > * the value in sb_features2 when formatting the incore superblock to
> > * the disk buffer.
> > */
> > - __uint32_t sb_bad_features2;
> > + uint32_t sb_bad_features2;
> >
> > /* version 5 superblock fields start here */
> >
> > /* feature masks */
> > - __uint32_t sb_features_compat;
> > - __uint32_t sb_features_ro_compat;
> > - __uint32_t sb_features_incompat;
> > - __uint32_t sb_features_log_incompat;
> > + uint32_t sb_features_compat;
> > + uint32_t sb_features_ro_compat;
> > + uint32_t sb_features_incompat;
> > + uint32_t sb_features_log_incompat;
> >
> > - __uint32_t sb_crc; /* superblock crc */
> > + uint32_t sb_crc; /* superblock crc */
> > xfs_extlen_t sb_spino_align; /* sparse inode chunk alignment */
> >
> > xfs_ino_t sb_pquotino; /* project quota inode */
> > @@ -449,7 +449,7 @@ static inline void xfs_sb_version_addprojid32bit(struct xfs_sb *sbp)
> > static inline bool
> > xfs_sb_has_compat_feature(
> > struct xfs_sb *sbp,
> > - __uint32_t feature)
> > + uint32_t feature)
> > {
> > return (sbp->sb_features_compat & feature) != 0;
> > }
> > @@ -465,7 +465,7 @@ xfs_sb_has_compat_feature(
> > static inline bool
> > xfs_sb_has_ro_compat_feature(
> > struct xfs_sb *sbp,
> > - __uint32_t feature)
> > + uint32_t feature)
> > {
> > return (sbp->sb_features_ro_compat & feature) != 0;
> > }
> > @@ -482,7 +482,7 @@ xfs_sb_has_ro_compat_feature(
> > static inline bool
> > xfs_sb_has_incompat_feature(
> > struct xfs_sb *sbp,
> > - __uint32_t feature)
> > + uint32_t feature)
> > {
> > return (sbp->sb_features_incompat & feature) != 0;
> > }
> > @@ -492,7 +492,7 @@ xfs_sb_has_incompat_feature(
> > static inline bool
> > xfs_sb_has_incompat_log_feature(
> > struct xfs_sb *sbp,
> > - __uint32_t feature)
> > + uint32_t feature)
> > {
> > return (sbp->sb_features_log_incompat & feature) != 0;
> > }
> > @@ -594,8 +594,8 @@ xfs_is_quota_inode(struct xfs_sb *sbp, xfs_ino_t ino)
> > */
> > #define XFS_FSB_TO_B(mp,fsbno) ((xfs_fsize_t)(fsbno) << (mp)->m_sb.sb_blocklog)
> > #define XFS_B_TO_FSB(mp,b) \
> > - ((((__uint64_t)(b)) + (mp)->m_blockmask) >> (mp)->m_sb.sb_blocklog)
> > -#define XFS_B_TO_FSBT(mp,b) (((__uint64_t)(b)) >> (mp)->m_sb.sb_blocklog)
> > + ((((uint64_t)(b)) + (mp)->m_blockmask) >> (mp)->m_sb.sb_blocklog)
> > +#define XFS_B_TO_FSBT(mp,b) (((uint64_t)(b)) >> (mp)->m_sb.sb_blocklog)
> > #define XFS_B_FSB_OFFSET(mp,b) ((b) & (mp)->m_blockmask)
> >
> > /*
> > @@ -1072,7 +1072,7 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
> > * next agno_log bits - ag number
> > * high agno_log-agblklog-inopblog bits - 0
> > */
> > -#define XFS_INO_MASK(k) (__uint32_t)((1ULL << (k)) - 1)
> > +#define XFS_INO_MASK(k) (uint32_t)((1ULL << (k)) - 1)
> > #define XFS_INO_OFFSET_BITS(mp) (mp)->m_sb.sb_inopblog
> > #define XFS_INO_AGBNO_BITS(mp) (mp)->m_sb.sb_agblklog
> > #define XFS_INO_AGINO_BITS(mp) (mp)->m_agino_log
> > @@ -1269,16 +1269,16 @@ typedef __be32 xfs_alloc_ptr_t;
> > #define XFS_FIBT_MAGIC 0x46494254 /* 'FIBT' */
> > #define XFS_FIBT_CRC_MAGIC 0x46494233 /* 'FIB3' */
> >
> > -typedef __uint64_t xfs_inofree_t;
> > +typedef uint64_t xfs_inofree_t;
> > #define XFS_INODES_PER_CHUNK (NBBY * sizeof(xfs_inofree_t))
> > #define XFS_INODES_PER_CHUNK_LOG (XFS_NBBYLOG + 3)
> > #define XFS_INOBT_ALL_FREE ((xfs_inofree_t)-1)
> > #define XFS_INOBT_MASK(i) ((xfs_inofree_t)1 << (i))
> >
> > #define XFS_INOBT_HOLEMASK_FULL 0 /* holemask for full chunk */
> > -#define XFS_INOBT_HOLEMASK_BITS (NBBY * sizeof(__uint16_t))
> > +#define XFS_INOBT_HOLEMASK_BITS (NBBY * sizeof(uint16_t))
> > #define XFS_INODES_PER_HOLEMASK_BIT \
> > - (XFS_INODES_PER_CHUNK / (NBBY * sizeof(__uint16_t)))
> > + (XFS_INODES_PER_CHUNK / (NBBY * sizeof(uint16_t)))
> >
> > static inline xfs_inofree_t xfs_inobt_maskn(int i, int n)
> > {
> > @@ -1312,9 +1312,9 @@ typedef struct xfs_inobt_rec {
> >
> > typedef struct xfs_inobt_rec_incore {
> > xfs_agino_t ir_startino; /* starting inode number */
> > - __uint16_t ir_holemask; /* hole mask for sparse chunks */
> > - __uint8_t ir_count; /* total inode count */
> > - __uint8_t ir_freecount; /* count of free inodes (set bits) */
> > + uint16_t ir_holemask; /* hole mask for sparse chunks */
> > + uint8_t ir_count; /* total inode count */
> > + uint8_t ir_freecount; /* count of free inodes (set bits) */
> > xfs_inofree_t ir_free; /* free inode mask */
> > } xfs_inobt_rec_incore_t;
> >
> > @@ -1397,15 +1397,15 @@ struct xfs_rmap_rec {
> > * rm_offset:54-60 aren't used and should be zero
> > * rm_offset:0-53 is the block offset within the inode
> > */
> > -#define XFS_RMAP_OFF_ATTR_FORK ((__uint64_t)1ULL << 63)
> > -#define XFS_RMAP_OFF_BMBT_BLOCK ((__uint64_t)1ULL << 62)
> > -#define XFS_RMAP_OFF_UNWRITTEN ((__uint64_t)1ULL << 61)
> > +#define XFS_RMAP_OFF_ATTR_FORK ((uint64_t)1ULL << 63)
> > +#define XFS_RMAP_OFF_BMBT_BLOCK ((uint64_t)1ULL << 62)
> > +#define XFS_RMAP_OFF_UNWRITTEN ((uint64_t)1ULL << 61)
> >
> > -#define XFS_RMAP_LEN_MAX ((__uint32_t)~0U)
> > +#define XFS_RMAP_LEN_MAX ((uint32_t)~0U)
> > #define XFS_RMAP_OFF_FLAGS (XFS_RMAP_OFF_ATTR_FORK | \
> > XFS_RMAP_OFF_BMBT_BLOCK | \
> > XFS_RMAP_OFF_UNWRITTEN)
> > -#define XFS_RMAP_OFF_MASK ((__uint64_t)0x3FFFFFFFFFFFFFULL)
> > +#define XFS_RMAP_OFF_MASK ((uint64_t)0x3FFFFFFFFFFFFFULL)
> >
> > #define XFS_RMAP_OFF(off) ((off) & XFS_RMAP_OFF_MASK)
> >
> > @@ -1431,8 +1431,8 @@ struct xfs_rmap_rec {
> > struct xfs_rmap_irec {
> > xfs_agblock_t rm_startblock; /* extent start block */
> > xfs_extlen_t rm_blockcount; /* extent length */
> > - __uint64_t rm_owner; /* extent owner */
> > - __uint64_t rm_offset; /* offset within the owner */
> > + uint64_t rm_owner; /* extent owner */
> > + uint64_t rm_offset; /* offset within the owner */
> > unsigned int rm_flags; /* state flags */
> > };
> >
> > @@ -1544,11 +1544,11 @@ typedef struct xfs_bmbt_rec {
> > __be64 l0, l1;
> > } xfs_bmbt_rec_t;
> >
> > -typedef __uint64_t xfs_bmbt_rec_base_t; /* use this for casts */
> > +typedef uint64_t xfs_bmbt_rec_base_t; /* use this for casts */
> > typedef xfs_bmbt_rec_t xfs_bmdr_rec_t;
> >
> > typedef struct xfs_bmbt_rec_host {
> > - __uint64_t l0, l1;
> > + uint64_t l0, l1;
> > } xfs_bmbt_rec_host_t;
> >
> > /*
> > diff --git a/libxfs/xfs_fs.h b/libxfs/xfs_fs.h
> > index 1831cff..2d28332 100644
> > --- a/libxfs/xfs_fs.h
> > +++ b/libxfs/xfs_fs.h
> > @@ -323,10 +323,10 @@ typedef struct xfs_bstat {
> > * and using two 16bit values to hold new 32bit projid was choosen
> > * to retain compatibility with "old" filesystems).
> > */
> > -static inline __uint32_t
> > +static inline uint32_t
> > bstat_get_projid(struct xfs_bstat *bs)
> > {
> > - return (__uint32_t)bs->bs_projid_hi << 16 | bs->bs_projid_lo;
> > + return (uint32_t)bs->bs_projid_hi << 16 | bs->bs_projid_lo;
> > }
> >
> > /*
> > @@ -476,10 +476,10 @@ typedef struct xfs_handle {
> > */
> > typedef struct xfs_swapext
> > {
> > - __int64_t sx_version; /* version */
> > + int64_t sx_version; /* version */
> > #define XFS_SX_VERSION 0
> > - __int64_t sx_fdtarget; /* fd of target file */
> > - __int64_t sx_fdtmp; /* fd of tmp file */
> > + int64_t sx_fdtarget; /* fd of target file */
> > + int64_t sx_fdtmp; /* fd of tmp file */
> > xfs_off_t sx_offset; /* offset into file */
> > xfs_off_t sx_length; /* leng from offset */
> > char sx_pad[16]; /* pad space, unused */
> > @@ -566,7 +566,7 @@ typedef struct xfs_swapext
> > #define XFS_IOC_ATTRLIST_BY_HANDLE _IOW ('X', 122, struct xfs_fsop_attrlist_handlereq)
> > #define XFS_IOC_ATTRMULTI_BY_HANDLE _IOW ('X', 123, struct xfs_fsop_attrmulti_handlereq)
> > #define XFS_IOC_FSGEOMETRY _IOR ('X', 124, struct xfs_fsop_geom)
> > -#define XFS_IOC_GOINGDOWN _IOR ('X', 125, __uint32_t)
> > +#define XFS_IOC_GOINGDOWN _IOR ('X', 125, uint32_t)
> > /* XFS_IOC_GETFSUUID ---------- deprecated 140 */
> >
> > /* reflink ioctls; these MUST match the btrfs ioctl definitions */
> > diff --git a/libxfs/xfs_ialloc.c b/libxfs/xfs_ialloc.c
> > index 55cc450..8d24518 100644
> > --- a/libxfs/xfs_ialloc.c
> > +++ b/libxfs/xfs_ialloc.c
> > @@ -134,9 +134,9 @@ xfs_inobt_get_rec(
> > STATIC int
> > xfs_inobt_insert_rec(
> > struct xfs_btree_cur *cur,
> > - __uint16_t holemask,
> > - __uint8_t count,
> > - __int32_t freecount,
> > + uint16_t holemask,
> > + uint8_t count,
> > + int32_t freecount,
> > xfs_inofree_t free,
> > int *stat)
> > {
> > diff --git a/libxfs/xfs_ialloc_btree.c b/libxfs/xfs_ialloc_btree.c
> > index 7b4be76..5b28105 100644
> > --- a/libxfs/xfs_ialloc_btree.c
> > +++ b/libxfs/xfs_ialloc_btree.c
> > @@ -218,12 +218,12 @@ xfs_finobt_init_ptr_from_cur(
> > ptr->s = agi->agi_free_root;
> > }
> >
> > -STATIC __int64_t
> > +STATIC int64_t
> > xfs_inobt_key_diff(
> > struct xfs_btree_cur *cur,
> > union xfs_btree_key *key)
> > {
> > - return (__int64_t)be32_to_cpu(key->inobt.ir_startino) -
> > + return (int64_t)be32_to_cpu(key->inobt.ir_startino) -
> > cur->bc_rec.i.ir_startino;
> > }
> >
> > diff --git a/libxfs/xfs_inode_buf.c b/libxfs/xfs_inode_buf.c
> > index 2972701..fcc6fb8 100644
> > --- a/libxfs/xfs_inode_buf.c
> > +++ b/libxfs/xfs_inode_buf.c
> > @@ -442,7 +442,7 @@ xfs_dinode_calc_crc(
> > struct xfs_mount *mp,
> > struct xfs_dinode *dip)
> > {
> > - __uint32_t crc;
> > + uint32_t crc;
> >
> > if (dip->di_version < 3)
> > return;
> > diff --git a/libxfs/xfs_inode_buf.h b/libxfs/xfs_inode_buf.h
> > index 6848a0a..0827d7d 100644
> > --- a/libxfs/xfs_inode_buf.h
> > +++ b/libxfs/xfs_inode_buf.h
> > @@ -28,26 +28,26 @@ struct xfs_dinode;
> > * format specific structures at the appropriate time.
> > */
> > struct xfs_icdinode {
> > - __int8_t di_version; /* inode version */
> > - __int8_t di_format; /* format of di_c data */
> > - __uint16_t di_flushiter; /* incremented on flush */
> > - __uint32_t di_uid; /* owner's user id */
> > - __uint32_t di_gid; /* owner's group id */
> > - __uint16_t di_projid_lo; /* lower part of owner's project id */
> > - __uint16_t di_projid_hi; /* higher part of owner's project id */
> > + int8_t di_version; /* inode version */
> > + int8_t di_format; /* format of di_c data */
> > + uint16_t di_flushiter; /* incremented on flush */
> > + uint32_t di_uid; /* owner's user id */
> > + uint32_t di_gid; /* owner's group id */
> > + uint16_t di_projid_lo; /* lower part of owner's project id */
> > + uint16_t di_projid_hi; /* higher part of owner's project id */
> > xfs_fsize_t di_size; /* number of bytes in file */
> > xfs_rfsblock_t di_nblocks; /* # of direct & btree blocks used */
> > xfs_extlen_t di_extsize; /* basic/minimum extent size for file */
> > xfs_extnum_t di_nextents; /* number of extents in data fork */
> > xfs_aextnum_t di_anextents; /* number of extents in attribute fork*/
> > - __uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */
> > - __int8_t di_aformat; /* format of attr fork's data */
> > - __uint32_t di_dmevmask; /* DMIG event mask */
> > - __uint16_t di_dmstate; /* DMIG state info */
> > - __uint16_t di_flags; /* random flags, XFS_DIFLAG_... */
> > + uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */
> > + int8_t di_aformat; /* format of attr fork's data */
> > + uint32_t di_dmevmask; /* DMIG event mask */
> > + uint16_t di_dmstate; /* DMIG state info */
> > + uint16_t di_flags; /* random flags, XFS_DIFLAG_... */
> >
> > - __uint64_t di_flags2; /* more random flags */
> > - __uint32_t di_cowextsize; /* basic cow extent size for file */
> > + uint64_t di_flags2; /* more random flags */
> > + uint32_t di_cowextsize; /* basic cow extent size for file */
> >
> > xfs_ictimestamp_t di_crtime; /* time created */
> > };
> > diff --git a/libxfs/xfs_log_format.h b/libxfs/xfs_log_format.h
> > index 7ae571f..8372e9b 100644
> > --- a/libxfs/xfs_log_format.h
> > +++ b/libxfs/xfs_log_format.h
> > @@ -31,7 +31,7 @@ struct xfs_trans_res;
> > * through all the log items definitions and everything they encode into the
> > * log.
> > */
> > -typedef __uint32_t xlog_tid_t;
> > +typedef uint32_t xlog_tid_t;
> >
> > #define XLOG_MIN_ICLOGS 2
> > #define XLOG_MAX_ICLOGS 8
> > @@ -211,7 +211,7 @@ typedef struct xfs_log_iovec {
> > typedef struct xfs_trans_header {
> > uint th_magic; /* magic number */
> > uint th_type; /* transaction type */
> > - __int32_t th_tid; /* transaction id (unused) */
> > + int32_t th_tid; /* transaction id (unused) */
> > uint th_num_items; /* num items logged by trans */
> > } xfs_trans_header_t;
> >
> > @@ -265,52 +265,52 @@ typedef struct xfs_trans_header {
> > * must be added on to the end.
> > */
> > typedef struct xfs_inode_log_format {
> > - __uint16_t ilf_type; /* inode log item type */
> > - __uint16_t ilf_size; /* size of this item */
> > - __uint32_t ilf_fields; /* flags for fields logged */
> > - __uint16_t ilf_asize; /* size of attr d/ext/root */
> > - __uint16_t ilf_dsize; /* size of data/ext/root */
> > - __uint64_t ilf_ino; /* inode number */
> > + uint16_t ilf_type; /* inode log item type */
> > + uint16_t ilf_size; /* size of this item */
> > + uint32_t ilf_fields; /* flags for fields logged */
> > + uint16_t ilf_asize; /* size of attr d/ext/root */
> > + uint16_t ilf_dsize; /* size of data/ext/root */
> > + uint64_t ilf_ino; /* inode number */
> > union {
> > - __uint32_t ilfu_rdev; /* rdev value for dev inode*/
> > + uint32_t ilfu_rdev; /* rdev value for dev inode*/
> > uuid_t ilfu_uuid; /* mount point value */
> > } ilf_u;
> > - __int64_t ilf_blkno; /* blkno of inode buffer */
> > - __int32_t ilf_len; /* len of inode buffer */
> > - __int32_t ilf_boffset; /* off of inode in buffer */
> > + int64_t ilf_blkno; /* blkno of inode buffer */
> > + int32_t ilf_len; /* len of inode buffer */
> > + int32_t ilf_boffset; /* off of inode in buffer */
> > } xfs_inode_log_format_t;
> >
> > typedef struct xfs_inode_log_format_32 {
> > - __uint16_t ilf_type; /* inode log item type */
> > - __uint16_t ilf_size; /* size of this item */
> > - __uint32_t ilf_fields; /* flags for fields logged */
> > - __uint16_t ilf_asize; /* size of attr d/ext/root */
> > - __uint16_t ilf_dsize; /* size of data/ext/root */
> > - __uint64_t ilf_ino; /* inode number */
> > + uint16_t ilf_type; /* inode log item type */
> > + uint16_t ilf_size; /* size of this item */
> > + uint32_t ilf_fields; /* flags for fields logged */
> > + uint16_t ilf_asize; /* size of attr d/ext/root */
> > + uint16_t ilf_dsize; /* size of data/ext/root */
> > + uint64_t ilf_ino; /* inode number */
> > union {
> > - __uint32_t ilfu_rdev; /* rdev value for dev inode*/
> > + uint32_t ilfu_rdev; /* rdev value for dev inode*/
> > uuid_t ilfu_uuid; /* mount point value */
> > } ilf_u;
> > - __int64_t ilf_blkno; /* blkno of inode buffer */
> > - __int32_t ilf_len; /* len of inode buffer */
> > - __int32_t ilf_boffset; /* off of inode in buffer */
> > + int64_t ilf_blkno; /* blkno of inode buffer */
> > + int32_t ilf_len; /* len of inode buffer */
> > + int32_t ilf_boffset; /* off of inode in buffer */
> > } __attribute__((packed)) xfs_inode_log_format_32_t;
> >
> > typedef struct xfs_inode_log_format_64 {
> > - __uint16_t ilf_type; /* inode log item type */
> > - __uint16_t ilf_size; /* size of this item */
> > - __uint32_t ilf_fields; /* flags for fields logged */
> > - __uint16_t ilf_asize; /* size of attr d/ext/root */
> > - __uint16_t ilf_dsize; /* size of data/ext/root */
> > - __uint32_t ilf_pad; /* pad for 64 bit boundary */
> > - __uint64_t ilf_ino; /* inode number */
> > + uint16_t ilf_type; /* inode log item type */
> > + uint16_t ilf_size; /* size of this item */
> > + uint32_t ilf_fields; /* flags for fields logged */
> > + uint16_t ilf_asize; /* size of attr d/ext/root */
> > + uint16_t ilf_dsize; /* size of data/ext/root */
> > + uint32_t ilf_pad; /* pad for 64 bit boundary */
> > + uint64_t ilf_ino; /* inode number */
> > union {
> > - __uint32_t ilfu_rdev; /* rdev value for dev inode*/
> > + uint32_t ilfu_rdev; /* rdev value for dev inode*/
> > uuid_t ilfu_uuid; /* mount point value */
> > } ilf_u;
> > - __int64_t ilf_blkno; /* blkno of inode buffer */
> > - __int32_t ilf_len; /* len of inode buffer */
> > - __int32_t ilf_boffset; /* off of inode in buffer */
> > + int64_t ilf_blkno; /* blkno of inode buffer */
> > + int32_t ilf_len; /* len of inode buffer */
> > + int32_t ilf_boffset; /* off of inode in buffer */
> > } xfs_inode_log_format_64_t;
> >
> >
> > @@ -379,8 +379,8 @@ static inline int xfs_ilog_fdata(int w)
> > * information.
> > */
> > typedef struct xfs_ictimestamp {
> > - __int32_t t_sec; /* timestamp seconds */
> > - __int32_t t_nsec; /* timestamp nanoseconds */
> > + int32_t t_sec; /* timestamp seconds */
> > + int32_t t_nsec; /* timestamp nanoseconds */
> > } xfs_ictimestamp_t;
> >
> > /*
> > @@ -388,18 +388,18 @@ typedef struct xfs_ictimestamp {
> > * kept identical to struct xfs_dinode except for the endianness annotations.
> > */
> > struct xfs_log_dinode {
> > - __uint16_t di_magic; /* inode magic # = XFS_DINODE_MAGIC */
> > - __uint16_t di_mode; /* mode and type of file */
> > - __int8_t di_version; /* inode version */
> > - __int8_t di_format; /* format of di_c data */
> > - __uint8_t di_pad3[2]; /* unused in v2/3 inodes */
> > - __uint32_t di_uid; /* owner's user id */
> > - __uint32_t di_gid; /* owner's group id */
> > - __uint32_t di_nlink; /* number of links to file */
> > - __uint16_t di_projid_lo; /* lower part of owner's project id */
> > - __uint16_t di_projid_hi; /* higher part of owner's project id */
> > - __uint8_t di_pad[6]; /* unused, zeroed space */
> > - __uint16_t di_flushiter; /* incremented on flush */
> > + uint16_t di_magic; /* inode magic # = XFS_DINODE_MAGIC */
> > + uint16_t di_mode; /* mode and type of file */
> > + int8_t di_version; /* inode version */
> > + int8_t di_format; /* format of di_c data */
> > + uint8_t di_pad3[2]; /* unused in v2/3 inodes */
> > + uint32_t di_uid; /* owner's user id */
> > + uint32_t di_gid; /* owner's group id */
> > + uint32_t di_nlink; /* number of links to file */
> > + uint16_t di_projid_lo; /* lower part of owner's project id */
> > + uint16_t di_projid_hi; /* higher part of owner's project id */
> > + uint8_t di_pad[6]; /* unused, zeroed space */
> > + uint16_t di_flushiter; /* incremented on flush */
> > xfs_ictimestamp_t di_atime; /* time last accessed */
> > xfs_ictimestamp_t di_mtime; /* time last modified */
> > xfs_ictimestamp_t di_ctime; /* time created/inode modified */
> > @@ -408,23 +408,23 @@ struct xfs_log_dinode {
> > xfs_extlen_t di_extsize; /* basic/minimum extent size for file */
> > xfs_extnum_t di_nextents; /* number of extents in data fork */
> > xfs_aextnum_t di_anextents; /* number of extents in attribute fork*/
> > - __uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */
> > - __int8_t di_aformat; /* format of attr fork's data */
> > - __uint32_t di_dmevmask; /* DMIG event mask */
> > - __uint16_t di_dmstate; /* DMIG state info */
> > - __uint16_t di_flags; /* random flags, XFS_DIFLAG_... */
> > - __uint32_t di_gen; /* generation number */
> > + uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */
> > + int8_t di_aformat; /* format of attr fork's data */
> > + uint32_t di_dmevmask; /* DMIG event mask */
> > + uint16_t di_dmstate; /* DMIG state info */
> > + uint16_t di_flags; /* random flags, XFS_DIFLAG_... */
> > + uint32_t di_gen; /* generation number */
> >
> > /* di_next_unlinked is the only non-core field in the old dinode */
> > xfs_agino_t di_next_unlinked;/* agi unlinked list ptr */
> >
> > /* start of the extended dinode, writable fields */
> > - __uint32_t di_crc; /* CRC of the inode */
> > - __uint64_t di_changecount; /* number of attribute changes */
> > + uint32_t di_crc; /* CRC of the inode */
> > + uint64_t di_changecount; /* number of attribute changes */
> > xfs_lsn_t di_lsn; /* flush sequence */
> > - __uint64_t di_flags2; /* more random flags */
> > - __uint32_t di_cowextsize; /* basic cow extent size for file */
> > - __uint8_t di_pad2[12]; /* more padding for future expansion */
> > + uint64_t di_flags2; /* more random flags */
> > + uint32_t di_cowextsize; /* basic cow extent size for file */
> > + uint8_t di_pad2[12]; /* more padding for future expansion */
> >
> > /* fields only written to during inode creation */
> > xfs_ictimestamp_t di_crtime; /* time created */
> > @@ -483,7 +483,7 @@ typedef struct xfs_buf_log_format {
> > unsigned short blf_size; /* size of this item */
> > unsigned short blf_flags; /* misc state */
> > unsigned short blf_len; /* number of blocks in this buf */
> > - __int64_t blf_blkno; /* starting blkno of this buf */
> > + int64_t blf_blkno; /* starting blkno of this buf */
> > unsigned int blf_map_size; /* used size of data bitmap in words */
> > unsigned int blf_data_map[XFS_BLF_DATAMAP_SIZE]; /* dirty bitmap */
> > } xfs_buf_log_format_t;
> > @@ -533,7 +533,7 @@ xfs_blft_to_flags(struct xfs_buf_log_format *blf, enum xfs_blft type)
> > blf->blf_flags |= ((type << XFS_BLFT_SHIFT) & XFS_BLFT_MASK);
> > }
> >
> > -static inline __uint16_t
> > +static inline uint16_t
> > xfs_blft_from_flags(struct xfs_buf_log_format *blf)
> > {
> > return (blf->blf_flags & XFS_BLFT_MASK) >> XFS_BLFT_SHIFT;
> > @@ -554,14 +554,14 @@ typedef struct xfs_extent {
> > * conversion routine.
> > */
> > typedef struct xfs_extent_32 {
> > - __uint64_t ext_start;
> > - __uint32_t ext_len;
> > + uint64_t ext_start;
> > + uint32_t ext_len;
> > } __attribute__((packed)) xfs_extent_32_t;
> >
> > typedef struct xfs_extent_64 {
> > - __uint64_t ext_start;
> > - __uint32_t ext_len;
> > - __uint32_t ext_pad;
> > + uint64_t ext_start;
> > + uint32_t ext_len;
> > + uint32_t ext_pad;
> > } xfs_extent_64_t;
> >
> > /*
> > @@ -570,26 +570,26 @@ typedef struct xfs_extent_64 {
> > * size is given by efi_nextents.
> > */
> > typedef struct xfs_efi_log_format {
> > - __uint16_t efi_type; /* efi log item type */
> > - __uint16_t efi_size; /* size of this item */
> > - __uint32_t efi_nextents; /* # extents to free */
> > - __uint64_t efi_id; /* efi identifier */
> > + uint16_t efi_type; /* efi log item type */
> > + uint16_t efi_size; /* size of this item */
> > + uint32_t efi_nextents; /* # extents to free */
> > + uint64_t efi_id; /* efi identifier */
> > xfs_extent_t efi_extents[1]; /* array of extents to free */
> > } xfs_efi_log_format_t;
> >
> > typedef struct xfs_efi_log_format_32 {
> > - __uint16_t efi_type; /* efi log item type */
> > - __uint16_t efi_size; /* size of this item */
> > - __uint32_t efi_nextents; /* # extents to free */
> > - __uint64_t efi_id; /* efi identifier */
> > + uint16_t efi_type; /* efi log item type */
> > + uint16_t efi_size; /* size of this item */
> > + uint32_t efi_nextents; /* # extents to free */
> > + uint64_t efi_id; /* efi identifier */
> > xfs_extent_32_t efi_extents[1]; /* array of extents to free */
> > } __attribute__((packed)) xfs_efi_log_format_32_t;
> >
> > typedef struct xfs_efi_log_format_64 {
> > - __uint16_t efi_type; /* efi log item type */
> > - __uint16_t efi_size; /* size of this item */
> > - __uint32_t efi_nextents; /* # extents to free */
> > - __uint64_t efi_id; /* efi identifier */
> > + uint16_t efi_type; /* efi log item type */
> > + uint16_t efi_size; /* size of this item */
> > + uint32_t efi_nextents; /* # extents to free */
> > + uint64_t efi_id; /* efi identifier */
> > xfs_extent_64_t efi_extents[1]; /* array of extents to free */
> > } xfs_efi_log_format_64_t;
> >
> > @@ -599,26 +599,26 @@ typedef struct xfs_efi_log_format_64 {
> > * size is given by efd_nextents;
> > */
> > typedef struct xfs_efd_log_format {
> > - __uint16_t efd_type; /* efd log item type */
> > - __uint16_t efd_size; /* size of this item */
> > - __uint32_t efd_nextents; /* # of extents freed */
> > - __uint64_t efd_efi_id; /* id of corresponding efi */
> > + uint16_t efd_type; /* efd log item type */
> > + uint16_t efd_size; /* size of this item */
> > + uint32_t efd_nextents; /* # of extents freed */
> > + uint64_t efd_efi_id; /* id of corresponding efi */
> > xfs_extent_t efd_extents[1]; /* array of extents freed */
> > } xfs_efd_log_format_t;
> >
> > typedef struct xfs_efd_log_format_32 {
> > - __uint16_t efd_type; /* efd log item type */
> > - __uint16_t efd_size; /* size of this item */
> > - __uint32_t efd_nextents; /* # of extents freed */
> > - __uint64_t efd_efi_id; /* id of corresponding efi */
> > + uint16_t efd_type; /* efd log item type */
> > + uint16_t efd_size; /* size of this item */
> > + uint32_t efd_nextents; /* # of extents freed */
> > + uint64_t efd_efi_id; /* id of corresponding efi */
> > xfs_extent_32_t efd_extents[1]; /* array of extents freed */
> > } __attribute__((packed)) xfs_efd_log_format_32_t;
> >
> > typedef struct xfs_efd_log_format_64 {
> > - __uint16_t efd_type; /* efd log item type */
> > - __uint16_t efd_size; /* size of this item */
> > - __uint32_t efd_nextents; /* # of extents freed */
> > - __uint64_t efd_efi_id; /* id of corresponding efi */
> > + uint16_t efd_type; /* efd log item type */
> > + uint16_t efd_size; /* size of this item */
> > + uint32_t efd_nextents; /* # of extents freed */
> > + uint64_t efd_efi_id; /* id of corresponding efi */
> > xfs_extent_64_t efd_extents[1]; /* array of extents freed */
> > } xfs_efd_log_format_64_t;
> >
> > @@ -626,11 +626,11 @@ typedef struct xfs_efd_log_format_64 {
> > * RUI/RUD (reverse mapping) log format definitions
> > */
> > struct xfs_map_extent {
> > - __uint64_t me_owner;
> > - __uint64_t me_startblock;
> > - __uint64_t me_startoff;
> > - __uint32_t me_len;
> > - __uint32_t me_flags;
> > + uint64_t me_owner;
> > + uint64_t me_startblock;
> > + uint64_t me_startoff;
> > + uint32_t me_len;
> > + uint32_t me_flags;
> > };
> >
> > /* rmap me_flags: upper bits are flags, lower byte is type code */
> > @@ -659,10 +659,10 @@ struct xfs_map_extent {
> > * size is given by rui_nextents.
> > */
> > struct xfs_rui_log_format {
> > - __uint16_t rui_type; /* rui log item type */
> > - __uint16_t rui_size; /* size of this item */
> > - __uint32_t rui_nextents; /* # extents to free */
> > - __uint64_t rui_id; /* rui identifier */
> > + uint16_t rui_type; /* rui log item type */
> > + uint16_t rui_size; /* size of this item */
> > + uint32_t rui_nextents; /* # extents to free */
> > + uint64_t rui_id; /* rui identifier */
> > struct xfs_map_extent rui_extents[]; /* array of extents to rmap */
> > };
> >
> > @@ -680,19 +680,19 @@ xfs_rui_log_format_sizeof(
> > * size is given by rud_nextents;
> > */
> > struct xfs_rud_log_format {
> > - __uint16_t rud_type; /* rud log item type */
> > - __uint16_t rud_size; /* size of this item */
> > - __uint32_t __pad;
> > - __uint64_t rud_rui_id; /* id of corresponding rui */
> > + uint16_t rud_type; /* rud log item type */
> > + uint16_t rud_size; /* size of this item */
> > + uint32_t __pad;
> > + uint64_t rud_rui_id; /* id of corresponding rui */
> > };
> >
> > /*
> > * CUI/CUD (refcount update) log format definitions
> > */
> > struct xfs_phys_extent {
> > - __uint64_t pe_startblock;
> > - __uint32_t pe_len;
> > - __uint32_t pe_flags;
> > + uint64_t pe_startblock;
> > + uint32_t pe_len;
> > + uint32_t pe_flags;
> > };
> >
> > /* refcount pe_flags: upper bits are flags, lower byte is type code */
> > @@ -707,10 +707,10 @@ struct xfs_phys_extent {
> > * size is given by cui_nextents.
> > */
> > struct xfs_cui_log_format {
> > - __uint16_t cui_type; /* cui log item type */
> > - __uint16_t cui_size; /* size of this item */
> > - __uint32_t cui_nextents; /* # extents to free */
> > - __uint64_t cui_id; /* cui identifier */
> > + uint16_t cui_type; /* cui log item type */
> > + uint16_t cui_size; /* size of this item */
> > + uint32_t cui_nextents; /* # extents to free */
> > + uint64_t cui_id; /* cui identifier */
> > struct xfs_phys_extent cui_extents[]; /* array of extents */
> > };
> >
> > @@ -728,10 +728,10 @@ xfs_cui_log_format_sizeof(
> > * size is given by cud_nextents;
> > */
> > struct xfs_cud_log_format {
> > - __uint16_t cud_type; /* cud log item type */
> > - __uint16_t cud_size; /* size of this item */
> > - __uint32_t __pad;
> > - __uint64_t cud_cui_id; /* id of corresponding cui */
> > + uint16_t cud_type; /* cud log item type */
> > + uint16_t cud_size; /* size of this item */
> > + uint32_t __pad;
> > + uint64_t cud_cui_id; /* id of corresponding cui */
> > };
> >
> > /*
> > @@ -755,10 +755,10 @@ struct xfs_cud_log_format {
> > * size is given by bui_nextents.
> > */
> > struct xfs_bui_log_format {
> > - __uint16_t bui_type; /* bui log item type */
> > - __uint16_t bui_size; /* size of this item */
> > - __uint32_t bui_nextents; /* # extents to free */
> > - __uint64_t bui_id; /* bui identifier */
> > + uint16_t bui_type; /* bui log item type */
> > + uint16_t bui_size; /* size of this item */
> > + uint32_t bui_nextents; /* # extents to free */
> > + uint64_t bui_id; /* bui identifier */
> > struct xfs_map_extent bui_extents[]; /* array of extents to bmap */
> > };
> >
> > @@ -776,10 +776,10 @@ xfs_bui_log_format_sizeof(
> > * size is given by bud_nextents;
> > */
> > struct xfs_bud_log_format {
> > - __uint16_t bud_type; /* bud log item type */
> > - __uint16_t bud_size; /* size of this item */
> > - __uint32_t __pad;
> > - __uint64_t bud_bui_id; /* id of corresponding bui */
> > + uint16_t bud_type; /* bud log item type */
> > + uint16_t bud_size; /* size of this item */
> > + uint32_t __pad;
> > + uint64_t bud_bui_id; /* id of corresponding bui */
> > };
> >
> > /*
> > @@ -789,12 +789,12 @@ struct xfs_bud_log_format {
> > * 32 bits : log_recovery code assumes that.
> > */
> > typedef struct xfs_dq_logformat {
> > - __uint16_t qlf_type; /* dquot log item type */
> > - __uint16_t qlf_size; /* size of this item */
> > + uint16_t qlf_type; /* dquot log item type */
> > + uint16_t qlf_size; /* size of this item */
> > xfs_dqid_t qlf_id; /* usr/grp/proj id : 32 bits */
> > - __int64_t qlf_blkno; /* blkno of dquot buffer */
> > - __int32_t qlf_len; /* len of dquot buffer */
> > - __uint32_t qlf_boffset; /* off of dquot in buffer */
> > + int64_t qlf_blkno; /* blkno of dquot buffer */
> > + int32_t qlf_len; /* len of dquot buffer */
> > + uint32_t qlf_boffset; /* off of dquot in buffer */
> > } xfs_dq_logformat_t;
> >
> > /*
> > @@ -853,8 +853,8 @@ typedef struct xfs_qoff_logformat {
> > * decoding can be done correctly.
> > */
> > struct xfs_icreate_log {
> > - __uint16_t icl_type; /* type of log format structure */
> > - __uint16_t icl_size; /* size of log format structure */
> > + uint16_t icl_type; /* type of log format structure */
> > + uint16_t icl_size; /* size of log format structure */
> > __be32 icl_ag; /* ag being allocated in */
> > __be32 icl_agbno; /* start block of inode range */
> > __be32 icl_count; /* number of inodes to initialise */
> > diff --git a/libxfs/xfs_quota_defs.h b/libxfs/xfs_quota_defs.h
> > index 8eed512..d69c772 100644
> > --- a/libxfs/xfs_quota_defs.h
> > +++ b/libxfs/xfs_quota_defs.h
> > @@ -27,8 +27,8 @@
> > * they may need 64-bit accounting. Hence, 64-bit quota-counters,
> > * and quota-limits. This is a waste in the common case, but hey ...
> > */
> > -typedef __uint64_t xfs_qcnt_t;
> > -typedef __uint16_t xfs_qwarncnt_t;
> > +typedef uint64_t xfs_qcnt_t;
> > +typedef uint16_t xfs_qwarncnt_t;
> >
> > /*
> > * flags for q_flags field in the dquot.
> > diff --git a/libxfs/xfs_refcount_btree.c b/libxfs/xfs_refcount_btree.c
> > index 2814f94..bd1a8f2 100644
> > --- a/libxfs/xfs_refcount_btree.c
> > +++ b/libxfs/xfs_refcount_btree.c
> > @@ -201,7 +201,7 @@ xfs_refcountbt_init_ptr_from_cur(
> > ptr->s = agf->agf_refcount_root;
> > }
> >
> > -STATIC __int64_t
> > +STATIC int64_t
> > xfs_refcountbt_key_diff(
> > struct xfs_btree_cur *cur,
> > union xfs_btree_key *key)
> > @@ -209,16 +209,16 @@ xfs_refcountbt_key_diff(
> > struct xfs_refcount_irec *rec = &cur->bc_rec.rc;
> > struct xfs_refcount_key *kp = &key->refc;
> >
> > - return (__int64_t)be32_to_cpu(kp->rc_startblock) - rec->rc_startblock;
> > + return (int64_t)be32_to_cpu(kp->rc_startblock) - rec->rc_startblock;
> > }
> >
> > -STATIC __int64_t
> > +STATIC int64_t
> > xfs_refcountbt_diff_two_keys(
> > struct xfs_btree_cur *cur,
> > union xfs_btree_key *k1,
> > union xfs_btree_key *k2)
> > {
> > - return (__int64_t)be32_to_cpu(k1->refc.rc_startblock) -
> > + return (int64_t)be32_to_cpu(k1->refc.rc_startblock) -
> > be32_to_cpu(k2->refc.rc_startblock);
> > }
> >
> > diff --git a/libxfs/xfs_rmap.c b/libxfs/xfs_rmap.c
> > index f78771d..0d6b5d4 100644
> > --- a/libxfs/xfs_rmap.c
> > +++ b/libxfs/xfs_rmap.c
> > @@ -2059,7 +2059,7 @@ int
> > xfs_rmap_finish_one(
> > struct xfs_trans *tp,
> > enum xfs_rmap_intent_type type,
> > - __uint64_t owner,
> > + uint64_t owner,
> > int whichfork,
> > xfs_fileoff_t startoff,
> > xfs_fsblock_t startblock,
> > @@ -2180,7 +2180,7 @@ __xfs_rmap_add(
> > struct xfs_mount *mp,
> > struct xfs_defer_ops *dfops,
> > enum xfs_rmap_intent_type type,
> > - __uint64_t owner,
> > + uint64_t owner,
> > int whichfork,
> > struct xfs_bmbt_irec *bmap)
> > {
> > @@ -2264,7 +2264,7 @@ xfs_rmap_alloc_extent(
> > xfs_agnumber_t agno,
> > xfs_agblock_t bno,
> > xfs_extlen_t len,
> > - __uint64_t owner)
> > + uint64_t owner)
> > {
> > struct xfs_bmbt_irec bmap;
> >
> > @@ -2288,7 +2288,7 @@ xfs_rmap_free_extent(
> > xfs_agnumber_t agno,
> > xfs_agblock_t bno,
> > xfs_extlen_t len,
> > - __uint64_t owner)
> > + uint64_t owner)
> > {
> > struct xfs_bmbt_irec bmap;
> >
> > diff --git a/libxfs/xfs_rmap.h b/libxfs/xfs_rmap.h
> > index 98f908f..265116d 100644
> > --- a/libxfs/xfs_rmap.h
> > +++ b/libxfs/xfs_rmap.h
> > @@ -179,7 +179,7 @@ enum xfs_rmap_intent_type {
> > struct xfs_rmap_intent {
> > struct list_head ri_list;
> > enum xfs_rmap_intent_type ri_type;
> > - __uint64_t ri_owner;
> > + uint64_t ri_owner;
> > int ri_whichfork;
> > struct xfs_bmbt_irec ri_bmap;
> > };
> > @@ -196,15 +196,15 @@ int xfs_rmap_convert_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
> > struct xfs_bmbt_irec *imap);
> > int xfs_rmap_alloc_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
> > xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len,
> > - __uint64_t owner);
> > + uint64_t owner);
> > int xfs_rmap_free_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
> > xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len,
> > - __uint64_t owner);
> > + uint64_t owner);
> >
> > void xfs_rmap_finish_one_cleanup(struct xfs_trans *tp,
> > struct xfs_btree_cur *rcur, int error);
> > int xfs_rmap_finish_one(struct xfs_trans *tp, enum xfs_rmap_intent_type type,
> > - __uint64_t owner, int whichfork, xfs_fileoff_t startoff,
> > + uint64_t owner, int whichfork, xfs_fileoff_t startoff,
> > xfs_fsblock_t startblock, xfs_filblks_t blockcount,
> > xfs_exntst_t state, struct xfs_btree_cur **pcur);
> >
> > diff --git a/libxfs/xfs_rmap_btree.c b/libxfs/xfs_rmap_btree.c
> > index a186c87..45ac436 100644
> > --- a/libxfs/xfs_rmap_btree.c
> > +++ b/libxfs/xfs_rmap_btree.c
> > @@ -197,7 +197,7 @@ xfs_rmapbt_init_high_key_from_rec(
> > union xfs_btree_key *key,
> > union xfs_btree_rec *rec)
> > {
> > - __uint64_t off;
> > + uint64_t off;
> > int adj;
> >
> > adj = be32_to_cpu(rec->rmap.rm_blockcount) - 1;
> > @@ -239,7 +239,7 @@ xfs_rmapbt_init_ptr_from_cur(
> > ptr->s = agf->agf_roots[cur->bc_btnum];
> > }
> >
> > -STATIC __int64_t
> > +STATIC int64_t
> > xfs_rmapbt_key_diff(
> > struct xfs_btree_cur *cur,
> > union xfs_btree_key *key)
> > @@ -247,9 +247,9 @@ xfs_rmapbt_key_diff(
> > struct xfs_rmap_irec *rec = &cur->bc_rec.r;
> > struct xfs_rmap_key *kp = &key->rmap;
> > __u64 x, y;
> > - __int64_t d;
> > + int64_t d;
> >
> > - d = (__int64_t)be32_to_cpu(kp->rm_startblock) - rec->rm_startblock;
> > + d = (int64_t)be32_to_cpu(kp->rm_startblock) - rec->rm_startblock;
> > if (d)
> > return d;
> >
> > @@ -269,7 +269,7 @@ xfs_rmapbt_key_diff(
> > return 0;
> > }
> >
> > -STATIC __int64_t
> > +STATIC int64_t
> > xfs_rmapbt_diff_two_keys(
> > struct xfs_btree_cur *cur,
> > union xfs_btree_key *k1,
> > @@ -277,10 +277,10 @@ xfs_rmapbt_diff_two_keys(
> > {
> > struct xfs_rmap_key *kp1 = &k1->rmap;
> > struct xfs_rmap_key *kp2 = &k2->rmap;
> > - __int64_t d;
> > + int64_t d;
> > __u64 x, y;
> >
> > - d = (__int64_t)be32_to_cpu(kp1->rm_startblock) -
> > + d = (int64_t)be32_to_cpu(kp1->rm_startblock) -
> > be32_to_cpu(kp2->rm_startblock);
> > if (d)
> > return d;
> > @@ -382,10 +382,10 @@ xfs_rmapbt_keys_inorder(
> > union xfs_btree_key *k1,
> > union xfs_btree_key *k2)
> > {
> > - __uint32_t x;
> > - __uint32_t y;
> > - __uint64_t a;
> > - __uint64_t b;
> > + uint32_t x;
> > + uint32_t y;
> > + uint64_t a;
> > + uint64_t b;
> >
> > x = be32_to_cpu(k1->rmap.rm_startblock);
> > y = be32_to_cpu(k2->rmap.rm_startblock);
> > @@ -412,10 +412,10 @@ xfs_rmapbt_recs_inorder(
> > union xfs_btree_rec *r1,
> > union xfs_btree_rec *r2)
> > {
> > - __uint32_t x;
> > - __uint32_t y;
> > - __uint64_t a;
> > - __uint64_t b;
> > + uint32_t x;
> > + uint32_t y;
> > + uint64_t a;
> > + uint64_t b;
> >
> > x = be32_to_cpu(r1->rmap.rm_startblock);
> > y = be32_to_cpu(r2->rmap.rm_startblock);
> > diff --git a/libxfs/xfs_rtbitmap.c b/libxfs/xfs_rtbitmap.c
> > index dbd2f88..8f8a99d 100644
> > --- a/libxfs/xfs_rtbitmap.c
> > +++ b/libxfs/xfs_rtbitmap.c
> > @@ -1006,7 +1006,7 @@ xfs_rtfree_extent(
> > mp->m_sb.sb_rextents) {
> > if (!(mp->m_rbmip->i_d.di_flags & XFS_DIFLAG_NEWRTBM))
> > mp->m_rbmip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM;
> > - *(__uint64_t *)&VFS_I(mp->m_rbmip)->i_atime = 0;
> > + *(uint64_t *)&VFS_I(mp->m_rbmip)->i_atime = 0;
> > xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE);
> > }
> > return 0;
> > diff --git a/libxfs/xfs_sb.c b/libxfs/xfs_sb.c
> > index 93a1819..51f6970 100644
> > --- a/libxfs/xfs_sb.c
> > +++ b/libxfs/xfs_sb.c
> > @@ -430,7 +430,7 @@ xfs_sb_quota_to_disk(
> > struct xfs_dsb *to,
> > struct xfs_sb *from)
> > {
> > - __uint16_t qflags = from->sb_qflags;
> > + uint16_t qflags = from->sb_qflags;
> >
> > to->sb_uquotino = cpu_to_be64(from->sb_uquotino);
> > if (xfs_sb_version_has_pquotino(from)) {
> > @@ -738,7 +738,7 @@ xfs_sb_mount_common(
> > mp->m_refc_mnr[1] = mp->m_refc_mxr[1] / 2;
> >
> > mp->m_bsize = XFS_FSB_TO_BB(mp, 1);
> > - mp->m_ialloc_inos = (int)MAX((__uint16_t)XFS_INODES_PER_CHUNK,
> > + mp->m_ialloc_inos = (int)MAX((uint16_t)XFS_INODES_PER_CHUNK,
> > sbp->sb_inopblock);
> > mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog;
> >
> > diff --git a/libxfs/xfs_types.h b/libxfs/xfs_types.h
> > index 717909f..0220159 100644
> > --- a/libxfs/xfs_types.h
> > +++ b/libxfs/xfs_types.h
> > @@ -18,34 +18,34 @@
> > #ifndef __XFS_TYPES_H__
> > #define __XFS_TYPES_H__
> >
> > -typedef __uint32_t prid_t; /* project ID */
> > +typedef uint32_t prid_t; /* project ID */
> >
> > -typedef __uint32_t xfs_agblock_t; /* blockno in alloc. group */
> > -typedef __uint32_t xfs_agino_t; /* inode # within allocation grp */
> > -typedef __uint32_t xfs_extlen_t; /* extent length in blocks */
> > -typedef __uint32_t xfs_agnumber_t; /* allocation group number */
> > -typedef __int32_t xfs_extnum_t; /* # of extents in a file */
> > -typedef __int16_t xfs_aextnum_t; /* # extents in an attribute fork */
> > -typedef __int64_t xfs_fsize_t; /* bytes in a file */
> > -typedef __uint64_t xfs_ufsize_t; /* unsigned bytes in a file */
> > +typedef uint32_t xfs_agblock_t; /* blockno in alloc. group */
> > +typedef uint32_t xfs_agino_t; /* inode # within allocation grp */
> > +typedef uint32_t xfs_extlen_t; /* extent length in blocks */
> > +typedef uint32_t xfs_agnumber_t; /* allocation group number */
> > +typedef int32_t xfs_extnum_t; /* # of extents in a file */
> > +typedef int16_t xfs_aextnum_t; /* # extents in an attribute fork */
> > +typedef int64_t xfs_fsize_t; /* bytes in a file */
> > +typedef uint64_t xfs_ufsize_t; /* unsigned bytes in a file */
> >
> > -typedef __int32_t xfs_suminfo_t; /* type of bitmap summary info */
> > -typedef __int32_t xfs_rtword_t; /* word type for bitmap manipulations */
> > +typedef int32_t xfs_suminfo_t; /* type of bitmap summary info */
> > +typedef int32_t xfs_rtword_t; /* word type for bitmap manipulations */
> >
> > -typedef __int64_t xfs_lsn_t; /* log sequence number */
> > -typedef __int32_t xfs_tid_t; /* transaction identifier */
> > +typedef int64_t xfs_lsn_t; /* log sequence number */
> > +typedef int32_t xfs_tid_t; /* transaction identifier */
> >
> > -typedef __uint32_t xfs_dablk_t; /* dir/attr block number (in file) */
> > -typedef __uint32_t xfs_dahash_t; /* dir/attr hash value */
> > +typedef uint32_t xfs_dablk_t; /* dir/attr block number (in file) */
> > +typedef uint32_t xfs_dahash_t; /* dir/attr hash value */
> >
> > -typedef __uint64_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */
> > -typedef __uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */
> > -typedef __uint64_t xfs_rtblock_t; /* extent (block) in realtime area */
> > -typedef __uint64_t xfs_fileoff_t; /* block number in a file */
> > -typedef __uint64_t xfs_filblks_t; /* number of blocks in a file */
> > +typedef uint64_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */
> > +typedef uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */
> > +typedef uint64_t xfs_rtblock_t; /* extent (block) in realtime area */
> > +typedef uint64_t xfs_fileoff_t; /* block number in a file */
> > +typedef uint64_t xfs_filblks_t; /* number of blocks in a file */
> >
> > -typedef __int64_t xfs_srtblock_t; /* signed version of xfs_rtblock_t */
> > -typedef __int64_t xfs_sfiloff_t; /* signed block number in a file */
> > +typedef int64_t xfs_srtblock_t; /* signed version of xfs_rtblock_t */
> > +typedef int64_t xfs_sfiloff_t; /* signed block number in a file */
> >
> > /*
> > * Null values for the types.
> > @@ -125,7 +125,7 @@ struct xfs_name {
> > * uid_t and gid_t are hard-coded to 32 bits in the inode.
> > * Hence, an 'id' in a dquot is 32 bits..
> > */
> > -typedef __uint32_t xfs_dqid_t;
> > +typedef uint32_t xfs_dqid_t;
> >
> > /*
> > * Constants for bit manipulations.
> > diff --git a/logprint/log_misc.c b/logprint/log_misc.c
> > index 0dfcfd1..fe27f15 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 0d399f1..0667e39 100644
> > --- a/mdrestore/xfs_mdrestore.c
> > +++ b/mdrestore/xfs_mdrestore.c
> > @@ -65,7 +65,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 89cd237..cf8cc39 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 930f3d2..45ab83c 100644
> > --- a/mkfs/xfs_mkfs.c
> > +++ b/mkfs/xfs_mkfs.c
> > @@ -708,9 +708,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
> > @@ -881,7 +881,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
> > @@ -913,7 +913,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,
> > @@ -937,7 +937,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,
> > @@ -962,7 +962,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
> > @@ -984,9 +984,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,
> > @@ -1062,7 +1062,7 @@ zero_old_xfs_structures(
> > {
> > void *buf;
> > xfs_sb_t sb;
> > - __uint32_t bsize;
> > + uint32_t bsize;
> > int i;
> > xfs_off_t off;
> >
> > @@ -1115,8 +1115,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;
> >
> > @@ -1136,7 +1136,7 @@ zero_old_xfs_structures(
> > }
> >
> > static void
> > -discard_blocks(dev_t dev, __uint64_t nsectors)
> > +discard_blocks(dev_t dev, uint64_t nsectors)
> > {
> > int fd;
> >
> > @@ -1398,11 +1398,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;
> > @@ -1477,10 +1477,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;
> > @@ -2165,7 +2165,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) {
> > @@ -2197,7 +2197,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) {
> > @@ -2214,7 +2214,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) {
> > @@ -2234,7 +2234,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) {
> > @@ -2250,8 +2250,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;
> > @@ -2329,10 +2329,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 */
> > @@ -2689,9 +2689,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;
> > @@ -2798,14 +2798,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;
> > @@ -2833,8 +2833,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 36b327a..8418e85 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 cee15ee..1f8378d 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 ccc154f..6378fbb 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 d09e239..479b970 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 4bde351..9ed28be 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 d0509c2..b2ea3bb 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 09dfa70..b08bf50 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 cafd45f..37840a8 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 7f168e6..4692463 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 6b2974c..2f7246d 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 7010e4f..294fad4 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 51cd624..8f4a121 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 @@ avl64_delete(
> > 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 fd19321..cd079a0 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 d664f87..da87217 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 61d0736..39d6a72 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 e6415e4..73dff90 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 4085ccc..800128a 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,16 +161,16 @@ 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)));
> > @@ -178,7 +178,7 @@ struct aglock {
> > EXTERN struct aglock *ag_locks;
> >
> > EXTERN int report_interval;
> > -EXTERN __uint64_t *prog_rpt_done;
> > +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 cb57316..a9191ae 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 c23a3a3..fd66084 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 7e6786c..0a8138a 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 2ec1765..3b6b44d 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 c21778b..0085732 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 0890a27..17b1c28 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 e59464b..cc17ec0 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 0b833f1..bf86730 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 08636dc..373b1a5 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 8bce117..4ffb81a 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 2a09b23..3a2e9a2 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 33db834..5152648 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 ab6e583..01d6f0f 100644
> > --- a/repair/rmap.c
> > +++ b/repair/rmap.c
> > @@ -343,7 +343,7 @@ _("Insufficient memory while allocating raw metadata reverse mapping slabs."));
> >
> > 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 @@ _("Incorrect reverse-mapping: saw (%u/%u) %slen %u owner %"PRId64" %s%soff \
> > * 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 752ece8..1616ab7 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 77e5154..acc9283 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 b9ef4dc..447611a 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 ea8c0bf..9bbe1e6 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(
> > --
> > To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> > the body of a message to majordomo@xxxxxxxxxxxxxxx
> > More majordomo info at http://vger.kernel.org/majordomo-info.html
> ---end quoted text---
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at http://vger.kernel.org/majordomo-info.html
--
To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
