Re: [PATCH 2/3] xfsprogs: remove double-underscore integer types

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



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?

> 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




[Index of Archives]     [XFS Filesystem Development (older mail)]     [Linux Filesystem Development]     [Linux Audio Users]     [Yosemite Trails]     [Linux Kernel]     [Linux RAID]     [Linux SCSI]


  Powered by Linux