xfs: remove double-underscore integer types
authorDarrick J. Wong <darrick.wong@oracle.com>
Fri, 16 Jun 2017 18:00:05 +0000 (11:00 -0700)
committerDarrick J. Wong <darrick.wong@oracle.com>
Mon, 19 Jun 2017 21:11:33 +0000 (14:11 -0700)
This is a purely mechanical patch that removes the private
__{u,}int{8,16,32,64}_t typedefs in favor of using the system
{u,}int{8,16,32,64}_t typedefs.  This is the sed script used to perform
the transformation and fix the resulting whitespace and indentation
errors:

s/typedef\t__uint8_t/typedef __uint8_t\t/g
s/typedef\t__uint/typedef __uint/g
s/typedef\t__int\([0-9]*\)_t/typedef int\1_t\t/g
s/__uint8_t\t/__uint8_t\t\t/g
s/__uint/uint/g
s/__int\([0-9]*\)_t\t/__int\1_t\t\t/g
s/__int/int/g
/^typedef.*int[0-9]*_t;$/d

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
61 files changed:
fs/xfs/libxfs/xfs_alloc_btree.c
fs/xfs/libxfs/xfs_attr_remote.c
fs/xfs/libxfs/xfs_attr_sf.h
fs/xfs/libxfs/xfs_bit.h
fs/xfs/libxfs/xfs_bmap_btree.c
fs/xfs/libxfs/xfs_btree.c
fs/xfs/libxfs/xfs_btree.h
fs/xfs/libxfs/xfs_cksum.h
fs/xfs/libxfs/xfs_da_btree.c
fs/xfs/libxfs/xfs_da_btree.h
fs/xfs/libxfs/xfs_da_format.c
fs/xfs/libxfs/xfs_da_format.h
fs/xfs/libxfs/xfs_dir2.h
fs/xfs/libxfs/xfs_dir2_leaf.c
fs/xfs/libxfs/xfs_dir2_priv.h
fs/xfs/libxfs/xfs_dir2_sf.c
fs/xfs/libxfs/xfs_format.h
fs/xfs/libxfs/xfs_fs.h
fs/xfs/libxfs/xfs_ialloc.c
fs/xfs/libxfs/xfs_ialloc_btree.c
fs/xfs/libxfs/xfs_inode_buf.c
fs/xfs/libxfs/xfs_inode_buf.h
fs/xfs/libxfs/xfs_log_format.h
fs/xfs/libxfs/xfs_log_recover.h
fs/xfs/libxfs/xfs_quota_defs.h
fs/xfs/libxfs/xfs_refcount_btree.c
fs/xfs/libxfs/xfs_rmap.c
fs/xfs/libxfs/xfs_rmap.h
fs/xfs/libxfs/xfs_rmap_btree.c
fs/xfs/libxfs/xfs_rtbitmap.c
fs/xfs/libxfs/xfs_sb.c
fs/xfs/libxfs/xfs_types.h
fs/xfs/xfs_aops.c
fs/xfs/xfs_attr_list.c
fs/xfs/xfs_bmap_util.c
fs/xfs/xfs_buf.c
fs/xfs/xfs_dir2_readdir.c
fs/xfs/xfs_discard.c
fs/xfs/xfs_dquot.c
fs/xfs/xfs_fsops.c
fs/xfs/xfs_fsops.h
fs/xfs/xfs_inode.c
fs/xfs/xfs_inode.h
fs/xfs/xfs_ioctl.c
fs/xfs/xfs_ioctl.h
fs/xfs/xfs_ioctl32.h
fs/xfs/xfs_linux.h
fs/xfs/xfs_log.c
fs/xfs/xfs_log.h
fs/xfs/xfs_log_priv.h
fs/xfs/xfs_log_recover.c
fs/xfs/xfs_mount.c
fs/xfs/xfs_mount.h
fs/xfs/xfs_qm_bhv.c
fs/xfs/xfs_rtalloc.c
fs/xfs/xfs_stats.c
fs/xfs/xfs_stats.h
fs/xfs/xfs_super.c
fs/xfs/xfs_trace.h
fs/xfs/xfs_trans.h
fs/xfs/xfs_trans_rmap.c

index e1fcfe7f0a9a4fb5665c296c6b171d69cdf80542..5020cbc02db851364a65697f71bb5564daad9d56 100644 (file)
@@ -253,7 +253,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)
@@ -261,42 +261,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);
index d52f525f5b2dffe74be16ccf1bae2494a02787d7..da72b16bef8ef7ab29163d62d70c8c799427aa16 100644 (file)
@@ -253,7 +253,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;
@@ -301,7 +301,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;
@@ -355,7 +355,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;
@@ -421,7 +421,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;
index 90928bbe693c03bcb5a74aecaac421ba3132bebe..afd684ae31365f061c1f4a6ba9b729293bf478ca 100644 (file)
@@ -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 */ \
index e1649c0d3e02f0f4da1ce1f8476008d53c7a8a3f..61c6b2025d0c83cbee67c8d4b156023e15ac0a2a 100644 (file)
 /*
  * 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)
index 6cba69aff077470752daa8457116ff57802575f2..5e2b3dc138ade4dccec10972d1beec08fe7dc8de 100644 (file)
@@ -94,8 +94,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;
@@ -588,12 +588,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;
 }
 
index d50517942273e0b49b7ef6b50225a555cf2e452e..2aac3f499d97c9ca8853d1674c31e1d27dc144e9 100644 (file)
@@ -43,7 +43,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,
@@ -51,12 +51,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);
@@ -778,14 +778,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);
        /*
@@ -1846,7 +1846,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;
index 27bed08261c530fac9508f9138f00b0f13a8cdd9..0a931f6441032003a7990971db2caeded7412357 100644 (file)
@@ -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);
 }
index a416c7cb23ea57ed44df6db0844f623beab1e4b7..8211f48b98e6d19c5abfd0f1db13cf8893d93424 100644 (file)
@@ -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);
 }
index 1bdf2888295b92761ab5e6bea7aa70e6bb6298dd..48f1136b80bf4c717750fe6487aee19d98b65c7e 100644 (file)
@@ -1952,7 +1952,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;
 
index 4e29cb6a36279515e3807de7be0d3b2d55cac8a2..ae6de17467f265b0d416b7e49d575aa0002552b2 100644 (file)
@@ -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);
 
index f1e8d4dbb60015093a76142e149b6db5ee2f9a57..6d77d1a8498ad62c6d3775f39ed9f4b8e5a5afd6 100644 (file)
@@ -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);
index 9a492a9e19bd0af9e52532ebb99ca7ec114b2f5d..3771edcb301d5ab748f15c8b62b5cd772128ce41 100644 (file)
@@ -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];
 };
 
index d6e6d9d16f6c30d90e88f742c077782bc678b86f..21c8f8bf94d52ebd62b7a9e41efb50fb6a8a8000 100644 (file)
@@ -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);
index b887fb2a2bcf5d39fdabe01d5fbd6a2b60410811..68bf3e860a90e58dd0a0f78d374aee8547571aff 100644 (file)
@@ -145,7 +145,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;
@@ -154,7 +154,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;
@@ -178,7 +178,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;
 
@@ -195,7 +195,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;
@@ -299,7 +299,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;
 
@@ -343,7 +343,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;
index 39f8604f764e13147fd576e95f5ad30f98dc4d1e..011df4da6cc23a85f6f6784466bd79ee99278237 100644 (file)
@@ -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,
index e84af093b2ab99e5d7a75467bc6d7a490682611a..be8b9755f66a0152cdca6a309b4c486aefcbe166 100644 (file)
@@ -647,7 +647,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);
        /*
index a1dccd8d96bcecaae119d7404f4c461022cab07d..e204a942e5bf308c0e56c6e683fb7e1c65540a74 100644 (file)
@@ -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;
 
 /*
index a9aa13e66046f7bac1db5006413aeb5956c0143c..8c61f21535d4f6fa90437ba830e95851e130b0cc 100644 (file)
@@ -302,10 +302,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;
 }
 
 /*
@@ -451,10 +451,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 */
@@ -542,7 +542,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      */
 
 
index d41ade5d293eba3421024ad80c2cd5ff9ef73ed8..1e5ed940b84d2358b9793023ee3dd8bc0e365281 100644 (file)
@@ -140,9 +140,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)
 {
index 7c471881c9a67482bd6bf88df59bd6f2e63a57a7..ed52d99732b8510eda34f78adeaea76617534e50 100644 (file)
@@ -219,12 +219,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;
 }
 
index 09c3d1aecef267cbb207e274f892542be22d1275..d887af940f09724c56324ef605730bec9210c112 100644 (file)
@@ -444,7 +444,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;
index 6848a0afbce7a4db3b03938858ca0e591cbf40ef..0827d7def1ce2f6a8eeca4a1018d02500ccd5155 100644 (file)
@@ -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 */
 };
index 7ae571f8e34ac738b9c1ed1d628e5bc17b0e7079..8372e9bcd7b6ba4b8fcc7b9133d5acecef4842e2 100644 (file)
@@ -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 */
index 29a01ec89dd095ff69edb54af08865bfa798c864..66948a9fd4861653058df5738ffa057355d58697 100644 (file)
@@ -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)
 
index 8eed51275bb39b4466f8457b3dc7ba0aa592a583..d69c772271cb0d882ceabbc0b5754c94ec4d5367 100644 (file)
@@ -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.
index 50add5272807e95374c3043819205f68c5ec55fa..65c222ae5b04805f3dbb54359210827fe6110687 100644 (file)
@@ -202,7 +202,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)
@@ -210,16 +210,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);
 }
 
index 06cfb93c2ef95b2c9454272db24d9ae7b7f6816a..1bcb41fe015671bcdc49315a62244a884c5154fe 100644 (file)
@@ -2061,7 +2061,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,
@@ -2182,7 +2182,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)
 {
@@ -2266,7 +2266,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;
 
@@ -2290,7 +2290,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;
 
index 98f908fea103508a55955c97fc42f9052cf3316b..265116d044f42baa8f952889e696fce77e8f7718 100644 (file)
@@ -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);
 
index 74e5a54bc428fa27d485d88e871fdd77f8494252..c5b4a1c862b0c9f5d56afb4cebec1433558e021c 100644 (file)
@@ -199,7 +199,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;
@@ -241,7 +241,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)
@@ -249,9 +249,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;
 
@@ -271,7 +271,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,
@@ -279,10 +279,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;
@@ -384,10 +384,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);
@@ -414,10 +414,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);
index e47b99e59f6035c0bb76a98aa76df998c659348c..26bba7f90fdfd4d44a8b40e72a27076d9622dbbe 100644 (file)
@@ -1011,7 +1011,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;
index 584ec896a53374f81da05906d517fba717686504..9b5aae2bcc0b7817922c25f24fb6c5324bb9ac1c 100644 (file)
@@ -448,7 +448,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)) {
@@ -756,7 +756,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;
 
index 717909f2f7b704be9c842a94155a2c88c5054a76..0220159bd4636e8febb3ece887aef02a4e519791 100644 (file)
 #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.
index 09af0f7cd55e278312881999755d3d8d0793d5c8..6bab8c449b8148add9ef644d00bf3977a930bac9 100644 (file)
@@ -836,7 +836,7 @@ xfs_writepage_map(
        struct inode            *inode,
        struct page             *page,
        loff_t                  offset,
-       __uint64_t              end_offset)
+       uint64_t              end_offset)
 {
        LIST_HEAD(submit_list);
        struct xfs_ioend        *ioend, *next;
@@ -991,7 +991,7 @@ xfs_do_writepage(
        struct xfs_writepage_ctx *wpc = data;
        struct inode            *inode = page->mapping->host;
        loff_t                  offset;
-       __uint64_t              end_offset;
+       uint64_t              end_offset;
        pgoff_t                 end_index;
 
        trace_xfs_writepage(inode, page, 0, 0);
index 97c45b6eb91ec31dcd39a412e4c6bd6c2d1b5583..9bc1e12179899637042953b37d983db16690e955 100644 (file)
@@ -279,7 +279,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
        if (bp == NULL) {
                cursor->blkno = 0;
                for (;;) {
-                       __uint16_t magic;
+                       uint16_t magic;
 
                        error = xfs_da3_node_read(NULL, dp,
                                                      cursor->blkno, -1, &bp,
index 7493a64f5b998e6dc21ba39fcdfee8b5dbcf451a..0ea70a44c1a7839541b7b9e333fe3c4fd0372c86 100644 (file)
@@ -389,11 +389,11 @@ xfs_getbmapx_fix_eof_hole(
        struct getbmapx         *out,           /* output structure */
        int                     prealloced,     /* this is a file with
                                                 * preallocated data space */
-       __int64_t               end,            /* last block requested */
+       int64_t                 end,            /* last block requested */
        xfs_fsblock_t           startblock,
        bool                    moretocome)
 {
-       __int64_t               fixlen;
+       int64_t                 fixlen;
        xfs_mount_t             *mp;            /* file system mount point */
        xfs_ifork_t             *ifp;           /* inode fork pointer */
        xfs_extnum_t            lastx;          /* last extent pointer */
@@ -514,9 +514,9 @@ xfs_getbmap(
        xfs_bmap_format_t       formatter,      /* format to user */
        void                    *arg)           /* formatter arg */
 {
-       __int64_t               bmvend;         /* last block requested */
+       int64_t                 bmvend;         /* last block requested */
        int                     error = 0;      /* return value */
-       __int64_t               fixlen;         /* length for -1 case */
+       int64_t                 fixlen;         /* length for -1 case */
        int                     i;              /* extent number */
        int                     lock;           /* lock state */
        xfs_bmbt_irec_t         *map;           /* buffer for user's data */
@@ -605,7 +605,7 @@ xfs_getbmap(
        if (bmv->bmv_length == -1) {
                fixlen = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, fixlen));
                bmv->bmv_length =
-                       max_t(__int64_t, fixlen - bmv->bmv_offset, 0);
+                       max_t(int64_t, fixlen - bmv->bmv_offset, 0);
        } else if (bmv->bmv_length == 0) {
                bmv->bmv_entries = 0;
                return 0;
@@ -742,7 +742,7 @@ xfs_getbmap(
                                out[cur_ext].bmv_offset +
                                out[cur_ext].bmv_length;
                        bmv->bmv_length =
-                               max_t(__int64_t, 0, bmvend - bmv->bmv_offset);
+                               max_t(int64_t, 0, bmvend - bmv->bmv_offset);
 
                        /*
                         * In case we don't want to return the hole,
@@ -1676,7 +1676,7 @@ xfs_swap_extent_rmap(
        xfs_filblks_t                   ilen;
        xfs_filblks_t                   rlen;
        int                             nimaps;
-       __uint64_t                      tip_flags2;
+       uint64_t                        tip_flags2;
 
        /*
         * If the source file has shared blocks, we must flag the donor
@@ -1792,7 +1792,7 @@ xfs_swap_extent_forks(
        int                     aforkblks = 0;
        int                     taforkblks = 0;
        xfs_extnum_t            nextents;
-       __uint64_t              tmp;
+       uint64_t                tmp;
        int                     error;
 
        /*
@@ -1850,15 +1850,15 @@ xfs_swap_extent_forks(
        /*
         * Fix the on-disk inode values
         */
-       tmp = (__uint64_t)ip->i_d.di_nblocks;
+       tmp = (uint64_t)ip->i_d.di_nblocks;
        ip->i_d.di_nblocks = tip->i_d.di_nblocks - taforkblks + aforkblks;
        tip->i_d.di_nblocks = tmp + taforkblks - aforkblks;
 
-       tmp = (__uint64_t) ip->i_d.di_nextents;
+       tmp = (uint64_t) ip->i_d.di_nextents;
        ip->i_d.di_nextents = tip->i_d.di_nextents;
        tip->i_d.di_nextents = tmp;
 
-       tmp = (__uint64_t) ip->i_d.di_format;
+       tmp = (uint64_t) ip->i_d.di_format;
        ip->i_d.di_format = tip->i_d.di_format;
        tip->i_d.di_format = tmp;
 
@@ -1927,7 +1927,7 @@ xfs_swap_extents(
        int                     error = 0;
        int                     lock_flags;
        struct xfs_ifork        *cowfp;
-       __uint64_t              f;
+       uint64_t                f;
        int                     resblks;
 
        /*
index a9640b136b32c47c4d6373178a3a1c7d075cb46f..89b586f688b0b6b0e17d9ee45af538e84eabef22 100644 (file)
@@ -1194,7 +1194,7 @@ xfs_buf_ioerror_alert(
 {
        xfs_alert(bp->b_target->bt_mount,
 "metadata I/O error: block 0x%llx (\"%s\") error %d numblks %d",
-               (__uint64_t)XFS_BUF_ADDR(bp), func, -bp->b_error, bp->b_length);
+               (uint64_t)XFS_BUF_ADDR(bp), func, -bp->b_error, bp->b_length);
 }
 
 int
index 1bc7401ea1b2501b174030b99e07b1c0b0df270a..ede4790753bc1d9def5c2c01beef05386e57eb61 100644 (file)
@@ -44,7 +44,7 @@ static unsigned char xfs_dir3_filetype_table[] = {
 static unsigned char
 xfs_dir3_get_dtype(
        struct xfs_mount        *mp,
-       __uint8_t               filetype)
+       uint8_t                 filetype)
 {
        if (!xfs_sb_version_hasftype(&mp->m_sb))
                return DT_UNKNOWN;
@@ -117,7 +117,7 @@ xfs_dir2_sf_getdents(
         */
        sfep = xfs_dir2_sf_firstentry(sfp);
        for (i = 0; i < sfp->count; i++) {
-               __uint8_t filetype;
+               uint8_t filetype;
 
                off = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
                                xfs_dir2_sf_get_offset(sfep));
@@ -194,7 +194,7 @@ xfs_dir2_block_getdents(
         * Each object is a real entry (dep) or an unused one (dup).
         */
        while (ptr < endptr) {
-               __uint8_t filetype;
+               uint8_t filetype;
 
                dup = (xfs_dir2_data_unused_t *)ptr;
                /*
@@ -391,7 +391,7 @@ xfs_dir2_leaf_getdents(
         * Get more blocks and readahead as necessary.
         */
        while (curoff < XFS_DIR2_LEAF_OFFSET) {
-               __uint8_t filetype;
+               uint8_t filetype;
 
                /*
                 * If we have no buffer, or we're off the end of the
index 6a05d278da64f666e525ca96dfae306face43565..b2cde54261822a514e5bbabb6d10ab3d4a1f9806 100644 (file)
@@ -39,7 +39,7 @@ xfs_trim_extents(
        xfs_daddr_t             start,
        xfs_daddr_t             end,
        xfs_daddr_t             minlen,
-       __uint64_t              *blocks_trimmed)
+       uint64_t                *blocks_trimmed)
 {
        struct block_device     *bdev = mp->m_ddev_targp->bt_bdev;
        struct xfs_btree_cur    *cur;
@@ -166,7 +166,7 @@ xfs_ioc_trim(
        struct fstrim_range     range;
        xfs_daddr_t             start, end, minlen;
        xfs_agnumber_t          start_agno, end_agno, agno;
-       __uint64_t              blocks_trimmed = 0;
+       uint64_t                blocks_trimmed = 0;
        int                     error, last_error = 0;
 
        if (!capable(CAP_SYS_ADMIN))
index 9d06cc30e875e147a5560bad24e5a55aedb65cf0..e57c6cce91aaba37ff7ed1323fe63027d5a86c2e 100644 (file)
@@ -276,7 +276,7 @@ xfs_qm_init_dquot_blk(
 void
 xfs_dquot_set_prealloc_limits(struct xfs_dquot *dqp)
 {
-       __uint64_t space;
+       uint64_t space;
 
        dqp->q_prealloc_hi_wmark = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
        dqp->q_prealloc_lo_wmark = be64_to_cpu(dqp->q_core.d_blk_softlimit);
index 6ccaae9eb0eeacbb0488aab25f36df86b332137f..8f22fc579dbba4abf9b609040802d24e9cf2f732 100644 (file)
@@ -602,7 +602,7 @@ xfs_growfs_data_private(
        if (nagimax)
                mp->m_maxagi = nagimax;
        if (mp->m_sb.sb_imax_pct) {
-               __uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
+               uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
                do_div(icount, 100);
                mp->m_maxicount = icount << mp->m_sb.sb_inopblog;
        } else
@@ -793,17 +793,17 @@ xfs_fs_counts(
 int
 xfs_reserve_blocks(
        xfs_mount_t             *mp,
-       __uint64_t              *inval,
+       uint64_t              *inval,
        xfs_fsop_resblks_t      *outval)
 {
-       __int64_t               lcounter, delta;
-       __int64_t               fdblks_delta = 0;
-       __uint64_t              request;
-       __int64_t               free;
+       int64_t                 lcounter, delta;
+       int64_t                 fdblks_delta = 0;
+       uint64_t                request;
+       int64_t                 free;
        int                     error = 0;
 
        /* If inval is null, report current values and return */
-       if (inval == (__uint64_t *)NULL) {
+       if (inval == (uint64_t *)NULL) {
                if (!outval)
                        return -EINVAL;
                outval->resblks = mp->m_resblks;
@@ -904,7 +904,7 @@ out:
 int
 xfs_fs_goingdown(
        xfs_mount_t     *mp,
-       __uint32_t      inflags)
+       uint32_t        inflags)
 {
        switch (inflags) {
        case XFS_FSOP_GOING_FLAGS_DEFAULT: {
index f34915898fea25376099af70fd417442af171815..2954c13a3acd2f044bf6c6a0c3988e673c900a70 100644 (file)
@@ -22,9 +22,9 @@ extern int xfs_fs_geometry(xfs_mount_t *mp, xfs_fsop_geom_t *geo, int nversion);
 extern int xfs_growfs_data(xfs_mount_t *mp, xfs_growfs_data_t *in);
 extern int xfs_growfs_log(xfs_mount_t *mp, xfs_growfs_log_t *in);
 extern int xfs_fs_counts(xfs_mount_t *mp, xfs_fsop_counts_t *cnt);
-extern int xfs_reserve_blocks(xfs_mount_t *mp, __uint64_t *inval,
+extern int xfs_reserve_blocks(xfs_mount_t *mp, uint64_t *inval,
                                xfs_fsop_resblks_t *outval);
-extern int xfs_fs_goingdown(xfs_mount_t *mp, __uint32_t inflags);
+extern int xfs_fs_goingdown(xfs_mount_t *mp, uint32_t inflags);
 
 extern int xfs_fs_reserve_ag_blocks(struct xfs_mount *mp);
 extern int xfs_fs_unreserve_ag_blocks(struct xfs_mount *mp);
index ec9826c565009e5244682beae93c4efc5261b487..ffbfe7d8bc6d9033c80044593326f83fe4bfb5be 100644 (file)
@@ -632,7 +632,7 @@ __xfs_iflock(
 
 STATIC uint
 _xfs_dic2xflags(
-       __uint16_t              di_flags,
+       uint16_t                di_flags,
        uint64_t                di_flags2,
        bool                    has_attr)
 {
@@ -855,8 +855,8 @@ xfs_ialloc(
                inode->i_version = 1;
                ip->i_d.di_flags2 = 0;
                ip->i_d.di_cowextsize = 0;
-               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;
        }
 
 
index 10e89fcb49d7441d0a4e5e931809562de4c4b754..677d0bfe1c2d3323d31972818d32985fec775cb0 100644 (file)
@@ -192,8 +192,8 @@ static inline void
 xfs_set_projid(struct xfs_inode *ip,
                prid_t projid)
 {
-       ip->i_d.di_projid_hi = (__uint16_t) (projid >> 16);
-       ip->i_d.di_projid_lo = (__uint16_t) (projid & 0xffff);
+       ip->i_d.di_projid_hi = (uint16_t) (projid >> 16);
+       ip->i_d.di_projid_lo = (uint16_t) (projid & 0xffff);
 }
 
 static inline prid_t
index f6af76975bc875a03a32f9e158887dfaa9455e64..8ffe4eac0b48364da0b2ade82fdbf7e9642652d4 100644 (file)
@@ -443,8 +443,8 @@ xfs_attrmulti_attr_get(
        struct inode            *inode,
        unsigned char           *name,
        unsigned char           __user *ubuf,
-       __uint32_t              *len,
-       __uint32_t              flags)
+       uint32_t                *len,
+       uint32_t                flags)
 {
        unsigned char           *kbuf;
        int                     error = -EFAULT;
@@ -472,8 +472,8 @@ xfs_attrmulti_attr_set(
        struct inode            *inode,
        unsigned char           *name,
        const unsigned char     __user *ubuf,
-       __uint32_t              len,
-       __uint32_t              flags)
+       uint32_t                len,
+       uint32_t                flags)
 {
        unsigned char           *kbuf;
        int                     error;
@@ -498,7 +498,7 @@ int
 xfs_attrmulti_attr_remove(
        struct inode            *inode,
        unsigned char           *name,
-       __uint32_t              flags)
+       uint32_t                flags)
 {
        int                     error;
 
@@ -876,7 +876,7 @@ xfs_merge_ioc_xflags(
 
 STATIC unsigned int
 xfs_di2lxflags(
-       __uint16_t      di_flags)
+       uint16_t        di_flags)
 {
        unsigned int    flags = 0;
 
@@ -1287,7 +1287,7 @@ xfs_ioctl_setattr_check_projid(
        struct fsxattr          *fa)
 {
        /* Disallow 32bit project ids if projid32bit feature is not enabled. */
-       if (fa->fsx_projid > (__uint16_t)-1 &&
+       if (fa->fsx_projid > (uint16_t)-1 &&
            !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
                return -EINVAL;
 
@@ -1931,7 +1931,7 @@ xfs_file_ioctl(
 
        case XFS_IOC_SET_RESBLKS: {
                xfs_fsop_resblks_t inout;
-               __uint64_t         in;
+               uint64_t           in;
 
                if (!capable(CAP_SYS_ADMIN))
                        return -EPERM;
@@ -2017,12 +2017,12 @@ xfs_file_ioctl(
        }
 
        case XFS_IOC_GOINGDOWN: {
-               __uint32_t in;
+               uint32_t in;
 
                if (!capable(CAP_SYS_ADMIN))
                        return -EPERM;
 
-               if (get_user(in, (__uint32_t __user *)arg))
+               if (get_user(in, (uint32_t __user *)arg))
                        return -EFAULT;
 
                return xfs_fs_goingdown(mp, in);
index 8b52881bfd9015d4dcd4c8d97932b626f8d57692..e86c3ea137d2d779113b1d7c3efbd6432aedc25e 100644 (file)
@@ -48,22 +48,22 @@ xfs_attrmulti_attr_get(
        struct inode            *inode,
        unsigned char           *name,
        unsigned char           __user *ubuf,
-       __uint32_t              *len,
-       __uint32_t              flags);
+       uint32_t                *len,
+       uint32_t                flags);
 
 extern int
 xfs_attrmulti_attr_set(
        struct inode            *inode,
        unsigned char           *name,
        const unsigned char     __user *ubuf,
-       __uint32_t              len,
-       __uint32_t              flags);
+       uint32_t                len,
+       uint32_t                flags);
 
 extern int
 xfs_attrmulti_attr_remove(
        struct inode            *inode,
        unsigned char           *name,
-       __uint32_t              flags);
+       uint32_t                flags);
 
 extern struct dentry *
 xfs_handle_to_dentry(
index b1bb45444df8ac48008a1f784c248cfdcb663f88..5492bcf6f442bc2e12977bf0ca5b7b9268d25a10 100644 (file)
@@ -112,9 +112,9 @@ typedef struct compat_xfs_fsop_handlereq {
 
 /* The bstat field in the swapext struct needs translation */
 typedef struct compat_xfs_swapext {
-       __int64_t               sx_version;     /* version */
-       __int64_t               sx_fdtarget;    /* fd of target file */
-       __int64_t               sx_fdtmp;       /* fd of tmp file */
+       int64_t                 sx_version;     /* version */
+       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 */
index 044fb0e15390c7c5538514ec2f49b72fa5942ade..ecdae42267d319128a3de5234826d7b78c53d9ca 100644 (file)
 /*
  * Kernel specific type declarations for XFS
  */
-typedef signed char            __int8_t;
-typedef unsigned char          __uint8_t;
-typedef signed short int       __int16_t;
-typedef unsigned short int     __uint16_t;
-typedef signed int             __int32_t;
-typedef unsigned int           __uint32_t;
-typedef signed long long int   __int64_t;
-typedef unsigned long long int __uint64_t;
 
 typedef __s64                  xfs_off_t;      /* <file offset> type */
 typedef unsigned long long     xfs_ino_t;      /* <inode> type */
@@ -186,22 +178,22 @@ extern struct xstats xfsstats;
  * are converting to the init_user_ns. The uid is later mapped to a particular
  * user namespace value when crossing the kernel/user boundary.
  */
-static inline __uint32_t xfs_kuid_to_uid(kuid_t uid)
+static inline uint32_t xfs_kuid_to_uid(kuid_t uid)
 {
        return from_kuid(&init_user_ns, uid);
 }
 
-static inline kuid_t xfs_uid_to_kuid(__uint32_t uid)
+static inline kuid_t xfs_uid_to_kuid(uint32_t uid)
 {
        return make_kuid(&init_user_ns, uid);
 }
 
-static inline __uint32_t xfs_kgid_to_gid(kgid_t gid)
+static inline uint32_t xfs_kgid_to_gid(kgid_t gid)
 {
        return from_kgid(&init_user_ns, gid);
 }
 
-static inline kgid_t xfs_gid_to_kgid(__uint32_t gid)
+static inline kgid_t xfs_gid_to_kgid(uint32_t gid)
 {
        return make_kgid(&init_user_ns, gid);
 }
@@ -231,14 +223,14 @@ static inline __u32 xfs_do_mod(void *a, __u32 b, int n)
 
 #define do_mod(a, b)   xfs_do_mod(&(a), (b), sizeof(a))
 
-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);
        return x * y;
 }
 
-static inline __uint64_t howmany_64(__uint64_t x, __uint32_t y)
+static inline uint64_t howmany_64(uint64_t x, uint32_t y)
 {
        x += y - 1;
        do_div(x, y);
index c8d0481033479763a88ffdfd6fd98728e59461e2..98b39cbae42dcf01fcf4b8e6d4987f3d93e04d37 100644 (file)
@@ -434,7 +434,7 @@ xfs_log_reserve(
        int                     unit_bytes,
        int                     cnt,
        struct xlog_ticket      **ticp,
-       __uint8_t               client,
+       uint8_t                 client,
        bool                    permanent)
 {
        struct xlog             *log = mp->m_log;
@@ -825,9 +825,9 @@ xfs_log_unmount_write(xfs_mount_t *mp)
                if (!error) {
                        /* 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 = {
                                .magic = XLOG_UNMOUNT_TYPE,
                        };
@@ -1665,7 +1665,7 @@ xlog_cksum(
        char                    *dp,
        int                     size)
 {
-       __uint32_t              crc;
+       uint32_t                crc;
 
        /* first generate the crc for the record header ... */
        crc = xfs_start_cksum_update((char *)rhead,
@@ -1828,7 +1828,7 @@ xlog_sync(
                 */
                dptr = (char *)&iclog->ic_header + count;
                for (i = 0; i < split; i += BBSIZE) {
-                       __uint32_t cycle = be32_to_cpu(*(__be32 *)dptr);
+                       uint32_t cycle = be32_to_cpu(*(__be32 *)dptr);
                        if (++cycle == XLOG_HEADER_MAGIC_NUM)
                                cycle++;
                        *(__be32 *)dptr = cpu_to_be32(cycle);
@@ -2412,8 +2412,8 @@ xlog_write(
                        }
 
                        reg = &vecp[index];
-                       ASSERT(reg->i_len % sizeof(__int32_t) == 0);
-                       ASSERT((unsigned long)ptr % sizeof(__int32_t) == 0);
+                       ASSERT(reg->i_len % sizeof(int32_t) == 0);
+                       ASSERT((unsigned long)ptr % sizeof(int32_t) == 0);
 
                        start_rec_copy = xlog_write_start_rec(ptr, ticket);
                        if (start_rec_copy) {
@@ -3192,7 +3192,7 @@ xlog_state_switch_iclogs(
        /* Round up to next log-sunit */
        if (xfs_sb_version_haslogv2(&log->l_mp->m_sb) &&
            log->l_mp->m_sb.sb_logsunit > 1) {
-               __uint32_t sunit_bb = BTOBB(log->l_mp->m_sb.sb_logsunit);
+               uint32_t sunit_bb = BTOBB(log->l_mp->m_sb.sb_logsunit);
                log->l_curr_block = roundup(log->l_curr_block, sunit_bb);
        }
 
@@ -3820,7 +3820,7 @@ xlog_verify_iclog(
        xlog_in_core_2_t        *xhdr;
        void                    *base_ptr, *ptr, *p;
        ptrdiff_t               field_offset;
-       __uint8_t               clientid;
+       uint8_t                 clientid;
        int                     len, i, j, k, op_len;
        int                     idx;
 
index cc5a9f1574e758ccb5eadf87808ea5862a6d6d4f..bf212772595cc6fede65e1fc4137405a0eb52d7f 100644 (file)
@@ -159,7 +159,7 @@ int   xfs_log_reserve(struct xfs_mount *mp,
                          int              length,
                          int              count,
                          struct xlog_ticket **ticket,
-                         __uint8_t        clientid,
+                         uint8_t                  clientid,
                          bool             permanent);
 int      xfs_log_regrant(struct xfs_mount *mp, struct xlog_ticket *tic);
 void      xfs_log_unmount(struct xfs_mount *mp);
index 62113a5d2504452df40bb55c0e01ab713a28e9af..51bf7b827387198d3bbc9f6db146abfcd3056a0c 100644 (file)
@@ -419,7 +419,7 @@ struct xlog {
 };
 
 #define XLOG_BUF_CANCEL_BUCKET(log, blkno) \
-       ((log)->l_buf_cancel_table + ((__uint64_t)blkno % XLOG_BC_TABLE_SIZE))
+       ((log)->l_buf_cancel_table + ((uint64_t)blkno % XLOG_BC_TABLE_SIZE))
 
 #define XLOG_FORCED_SHUTDOWN(log)      ((log)->l_flags & XLOG_IO_ERROR)
 
index cd0b077deb354b6de5dda287cffaeb351e0e8cce..e19b20c87f355b7a315233efaf0def509a534d87 100644 (file)
@@ -2230,9 +2230,9 @@ xlog_recover_get_buf_lsn(
        struct xfs_mount        *mp,
        struct xfs_buf          *bp)
 {
-       __uint32_t              magic32;
-       __uint16_t              magic16;
-       __uint16_t              magicda;
+       uint32_t                magic32;
+       uint16_t                magic16;
+       uint16_t                magicda;
        void                    *blk = bp->b_addr;
        uuid_t                  *uuid;
        xfs_lsn_t               lsn = -1;
@@ -2381,9 +2381,9 @@ xlog_recover_validate_buf_type(
        xfs_lsn_t               current_lsn)
 {
        struct xfs_da_blkinfo   *info = bp->b_addr;
-       __uint32_t              magic32;
-       __uint16_t              magic16;
-       __uint16_t              magicda;
+       uint32_t                magic32;
+       uint16_t                magic16;
+       uint16_t                magicda;
        char                    *warnmsg = NULL;
 
        /*
@@ -2852,7 +2852,7 @@ xlog_recover_buffer_pass2(
        if (XFS_DINODE_MAGIC ==
            be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
            (BBTOB(bp->b_io_length) != MAX(log->l_mp->m_sb.sb_blocksize,
-                       (__uint32_t)log->l_mp->m_inode_cluster_size))) {
+                       (uint32_t)log->l_mp->m_inode_cluster_size))) {
                xfs_buf_stale(bp);
                error = xfs_bwrite(bp);
        } else {
@@ -3423,7 +3423,7 @@ xlog_recover_efd_pass2(
        xfs_efd_log_format_t    *efd_formatp;
        xfs_efi_log_item_t      *efip = NULL;
        xfs_log_item_t          *lip;
-       __uint64_t              efi_id;
+       uint64_t                efi_id;
        struct xfs_ail_cursor   cur;
        struct xfs_ail          *ailp = log->l_ailp;
 
@@ -3519,7 +3519,7 @@ xlog_recover_rud_pass2(
        struct xfs_rud_log_format       *rud_formatp;
        struct xfs_rui_log_item         *ruip = NULL;
        struct xfs_log_item             *lip;
-       __uint64_t                      rui_id;
+       uint64_t                        rui_id;
        struct xfs_ail_cursor           cur;
        struct xfs_ail                  *ailp = log->l_ailp;
 
@@ -3635,7 +3635,7 @@ xlog_recover_cud_pass2(
        struct xfs_cud_log_format       *cud_formatp;
        struct xfs_cui_log_item         *cuip = NULL;
        struct xfs_log_item             *lip;
-       __uint64_t                      cui_id;
+       uint64_t                        cui_id;
        struct xfs_ail_cursor           cur;
        struct xfs_ail                  *ailp = log->l_ailp;
 
@@ -3754,7 +3754,7 @@ xlog_recover_bud_pass2(
        struct xfs_bud_log_format       *bud_formatp;
        struct xfs_bui_log_item         *buip = NULL;
        struct xfs_log_item             *lip;
-       __uint64_t                      bui_id;
+       uint64_t                        bui_id;
        struct xfs_ail_cursor           cur;
        struct xfs_ail                  *ailp = log->l_ailp;
 
@@ -5772,9 +5772,9 @@ xlog_recover_check_summary(
        xfs_buf_t       *agfbp;
        xfs_buf_t       *agibp;
        xfs_agnumber_t  agno;
-       __uint64_t      freeblks;
-       __uint64_t      itotal;
-       __uint64_t      ifree;
+       uint64_t        freeblks;
+       uint64_t        itotal;
+       uint64_t        ifree;
        int             error;
 
        mp = log->l_mp;
index 2eaf8185916610ee115ebd98f8869f2df59b5fe9..cc6789d352320af20978bf8063665578a2370c75 100644 (file)
@@ -174,7 +174,7 @@ xfs_free_perag(
 int
 xfs_sb_validate_fsb_count(
        xfs_sb_t        *sbp,
-       __uint64_t      nblocks)
+       uint64_t        nblocks)
 {
        ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
        ASSERT(sbp->sb_blocklog >= BBSHIFT);
@@ -436,7 +436,7 @@ STATIC void
 xfs_set_maxicount(xfs_mount_t *mp)
 {
        xfs_sb_t        *sbp = &(mp->m_sb);
-       __uint64_t      icount;
+       uint64_t        icount;
 
        if (sbp->sb_imax_pct) {
                /*
@@ -502,7 +502,7 @@ xfs_set_low_space_thresholds(
        int i;
 
        for (i = 0; i < XFS_LOWSP_MAX; i++) {
-               __uint64_t space = mp->m_sb.sb_dblocks;
+               uint64_t space = mp->m_sb.sb_dblocks;
 
                do_div(space, 100);
                mp->m_low_space[i] = space * (i + 1);
@@ -598,10 +598,10 @@ xfs_mount_reset_sbqflags(
        return xfs_sync_sb(mp, false);
 }
 
-__uint64_t
+uint64_t
 xfs_default_resblks(xfs_mount_t *mp)
 {
-       __uint64_t resblks;
+       uint64_t resblks;
 
        /*
         * We default to 5% or 8192 fsbs of space reserved, whichever is
@@ -612,7 +612,7 @@ xfs_default_resblks(xfs_mount_t *mp)
         */
        resblks = mp->m_sb.sb_dblocks;
        do_div(resblks, 20);
-       resblks = min_t(__uint64_t, resblks, 8192);
+       resblks = min_t(uint64_t, resblks, 8192);
        return resblks;
 }
 
@@ -632,7 +632,7 @@ xfs_mountfs(
 {
        struct xfs_sb           *sbp = &(mp->m_sb);
        struct xfs_inode        *rip;
-       __uint64_t              resblks;
+       uint64_t                resblks;
        uint                    quotamount = 0;
        uint                    quotaflags = 0;
        int                     error = 0;
@@ -1060,7 +1060,7 @@ void
 xfs_unmountfs(
        struct xfs_mount        *mp)
 {
-       __uint64_t              resblks;
+       uint64_t                resblks;
        int                     error;
 
        cancel_delayed_work_sync(&mp->m_eofblocks_work);
index 9fa312a41c930cc188ec14f43097b0400a07bb27..305d95394e2d1938562df4302b10097c9cd10486 100644 (file)
@@ -108,10 +108,10 @@ typedef struct xfs_mount {
        xfs_buftarg_t           *m_ddev_targp;  /* saves taking the address */
        xfs_buftarg_t           *m_logdev_targp;/* ptr to log device */
        xfs_buftarg_t           *m_rtdev_targp; /* ptr to rt device */
-       __uint8_t               m_blkbit_log;   /* blocklog + NBBY */
-       __uint8_t               m_blkbb_log;    /* blocklog - BBSHIFT */
-       __uint8_t               m_agno_log;     /* log #ag's */
-       __uint8_t               m_agino_log;    /* #bits for agino in inum */
+       uint8_t                 m_blkbit_log;   /* blocklog + NBBY */
+       uint8_t                 m_blkbb_log;    /* blocklog - 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 */
@@ -139,7 +139,7 @@ typedef struct xfs_mount {
        struct mutex            m_growlock;     /* growfs mutex */
        int                     m_fixedfsid[2]; /* unchanged for life of FS */
        uint                    m_dmevmask;     /* DMI events for this FS */
-       __uint64_t              m_flags;        /* global mount flags */
+       uint64_t                m_flags;        /* global mount flags */
        bool                    m_inotbt_nores; /* no per-AG finobt resv. */
        int                     m_ialloc_inos;  /* inodes in inode allocation */
        int                     m_ialloc_blks;  /* blocks in inode allocation */
@@ -148,14 +148,14 @@ typedef struct xfs_mount {
        int                     m_inoalign_mask;/* mask sb_inoalignmt if used */
        uint                    m_qflags;       /* quota status flags */
        struct xfs_trans_resv   m_resv;         /* precomputed res values */
-       __uint64_t              m_maxicount;    /* maximum inode count */
-       __uint64_t              m_resblks;      /* total reserved blocks */
-       __uint64_t              m_resblks_avail;/* available reserved blocks */
-       __uint64_t              m_resblks_save; /* reserved blks @ remount,ro */
+       uint64_t                m_maxicount;    /* maximum inode count */
+       uint64_t                m_resblks;      /* total reserved blocks */
+       uint64_t                m_resblks_avail;/* available reserved blocks */
+       uint64_t                m_resblks_save; /* reserved blks @ remount,ro */
        int                     m_dalign;       /* stripe unit */
        int                     m_swidth;       /* stripe width */
        int                     m_sinoalign;    /* stripe unit inode alignment */
-       __uint8_t               m_sectbb_log;   /* sectlog - BBSHIFT */
+       uint8_t                 m_sectbb_log;   /* sectlog - BBSHIFT */
        const struct xfs_nameops *m_dirnameops; /* vector of dir name ops */
        const struct xfs_dir_ops *m_dir_inode_ops; /* vector of dir inode ops */
        const struct xfs_dir_ops *m_nondir_inode_ops; /* !dir inode ops */
@@ -194,7 +194,7 @@ typedef struct xfs_mount {
         * ever support shrinks it would have to be persisted in addition
         * to various other kinds of pain inflicted on the pNFS server.
         */
-       __uint32_t              m_generation;
+       uint32_t                m_generation;
 
        bool                    m_fail_unmount;
 #ifdef DEBUG
@@ -367,12 +367,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 */
 
@@ -411,7 +411,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 *
@@ -434,7 +434,7 @@ void xfs_buf_hash_destroy(xfs_perag_t *pag);
 
 extern void    xfs_uuid_table_free(void);
 extern int     xfs_log_sbcount(xfs_mount_t *);
-extern __uint64_t xfs_default_resblks(xfs_mount_t *mp);
+extern uint64_t xfs_default_resblks(xfs_mount_t *mp);
 extern int     xfs_mountfs(xfs_mount_t *mp);
 extern int     xfs_initialize_perag(xfs_mount_t *mp, xfs_agnumber_t agcount,
                                     xfs_agnumber_t *maxagi);
@@ -450,7 +450,7 @@ extern struct xfs_buf *xfs_getsb(xfs_mount_t *, int);
 extern int     xfs_readsb(xfs_mount_t *, int);
 extern void    xfs_freesb(xfs_mount_t *);
 extern bool    xfs_fs_writable(struct xfs_mount *mp, int level);
-extern int     xfs_sb_validate_fsb_count(struct xfs_sb *, __uint64_t);
+extern int     xfs_sb_validate_fsb_count(struct xfs_sb *, uint64_t);
 
 extern int     xfs_dev_is_read_only(struct xfs_mount *, char *);
 
index 3e52d5de7ae1e64dcd62c9faf29d10620ac2fe67..2be6d2735ca9f5d51b610e2f0b7563b64d15d263 100644 (file)
@@ -33,7 +33,7 @@ xfs_fill_statvfs_from_dquot(
        struct kstatfs          *statp,
        struct xfs_dquot        *dqp)
 {
-       __uint64_t              limit;
+       uint64_t                limit;
 
        limit = dqp->q_core.d_blk_softlimit ?
                be64_to_cpu(dqp->q_core.d_blk_softlimit) :
index c57aa7f18087733f40ac1ba398cb0605e1df109c..91472193643b15420e312074f2ccce5b36a5bf6e 100644 (file)
@@ -1256,13 +1256,13 @@ xfs_rtpick_extent(
 {
        xfs_rtblock_t   b;              /* result block */
        int             log2;           /* log of sequence number */
-       __uint64_t      resid;          /* residual after log removed */
-       __uint64_t      seq;            /* sequence number of file creation */
-       __uint64_t      *seqp;          /* pointer to seqno in inode */
+       uint64_t        resid;          /* residual after log removed */
+       uint64_t        seq;            /* sequence number of file creation */
+       uint64_t        *seqp;          /* pointer to seqno in inode */
 
        ASSERT(xfs_isilocked(mp->m_rbmip, XFS_ILOCK_EXCL));
 
-       seqp = (__uint64_t *)&VFS_I(mp->m_rbmip)->i_atime;
+       seqp = (uint64_t *)&VFS_I(mp->m_rbmip)->i_atime;
        if (!(mp->m_rbmip->i_d.di_flags & XFS_DIFLAG_NEWRTBM)) {
                mp->m_rbmip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM;
                *seqp = 0;
index f11282c96887ac969f95c6cc4e7c9c6f3e1612fd..056e12b421ebc14b418b0e25250f61f87461fe4d 100644 (file)
@@ -33,9 +33,9 @@ int xfs_stats_format(struct xfsstats __percpu *stats, char *buf)
 {
        int             i, j;
        int             len = 0;
-       __uint64_t      xs_xstrat_bytes = 0;
-       __uint64_t      xs_write_bytes = 0;
-       __uint64_t      xs_read_bytes = 0;
+       uint64_t        xs_xstrat_bytes = 0;
+       uint64_t        xs_write_bytes = 0;
+       uint64_t        xs_read_bytes = 0;
 
        static const struct xstats_entry {
                char    *desc;
@@ -100,7 +100,7 @@ int xfs_stats_format(struct xfsstats __percpu *stats, char *buf)
 void xfs_stats_clearall(struct xfsstats __percpu *stats)
 {
        int             c;
-       __uint32_t      vn_active;
+       uint32_t        vn_active;
 
        xfs_notice(NULL, "Clearing xfsstats");
        for_each_possible_cpu(c) {
index 375840f5a99aa1176f6ff25c4ab31354268150ca..f64d0ae345c4d7b5dd3759fc2340572373a71743 100644 (file)
@@ -54,125 +54,125 @@ enum {
  */
 struct __xfsstats {
 # define XFSSTAT_END_EXTENT_ALLOC      4
-       __uint32_t              xs_allocx;
-       __uint32_t              xs_allocb;
-       __uint32_t              xs_freex;
-       __uint32_t              xs_freeb;
+       uint32_t                xs_allocx;
+       uint32_t                xs_allocb;
+       uint32_t                xs_freex;
+       uint32_t                xs_freeb;
 # define XFSSTAT_END_ALLOC_BTREE       (XFSSTAT_END_EXTENT_ALLOC+4)
-       __uint32_t              xs_abt_lookup;
-       __uint32_t              xs_abt_compare;
-       __uint32_t              xs_abt_insrec;
-       __uint32_t              xs_abt_delrec;
+       uint32_t                xs_abt_lookup;
+       uint32_t                xs_abt_compare;
+       uint32_t                xs_abt_insrec;
+       uint32_t                xs_abt_delrec;
 # define XFSSTAT_END_BLOCK_MAPPING     (XFSSTAT_END_ALLOC_BTREE+7)
-       __uint32_t              xs_blk_mapr;
-       __uint32_t              xs_blk_mapw;
-       __uint32_t              xs_blk_unmap;
-       __uint32_t              xs_add_exlist;
-       __uint32_t              xs_del_exlist;
-       __uint32_t              xs_look_exlist;
-       __uint32_t              xs_cmp_exlist;
+       uint32_t                xs_blk_mapr;
+       uint32_t                xs_blk_mapw;
+       uint32_t                xs_blk_unmap;
+       uint32_t                xs_add_exlist;
+       uint32_t                xs_del_exlist;
+       uint32_t                xs_look_exlist;
+       uint32_t                xs_cmp_exlist;
 # define XFSSTAT_END_BLOCK_MAP_BTREE   (XFSSTAT_END_BLOCK_MAPPING+4)
-       __uint32_t              xs_bmbt_lookup;
-       __uint32_t              xs_bmbt_compare;
-       __uint32_t              xs_bmbt_insrec;
-       __uint32_t              xs_bmbt_delrec;
+       uint32_t                xs_bmbt_lookup;
+       uint32_t                xs_bmbt_compare;
+       uint32_t                xs_bmbt_insrec;
+       uint32_t                xs_bmbt_delrec;
 # define XFSSTAT_END_DIRECTORY_OPS     (XFSSTAT_END_BLOCK_MAP_BTREE+4)
-       __uint32_t              xs_dir_lookup;
-       __uint32_t              xs_dir_create;
-       __uint32_t              xs_dir_remove;
-       __uint32_t              xs_dir_getdents;
+       uint32_t                xs_dir_lookup;
+       uint32_t                xs_dir_create;
+       uint32_t                xs_dir_remove;
+       uint32_t                xs_dir_getdents;
 # define XFSSTAT_END_TRANSACTIONS      (XFSSTAT_END_DIRECTORY_OPS+3)
-       __uint32_t              xs_trans_sync;
-       __uint32_t              xs_trans_async;
-       __uint32_t              xs_trans_empty;
+       uint32_t                xs_trans_sync;
+       uint32_t                xs_trans_async;
+       uint32_t                xs_trans_empty;
 # define XFSSTAT_END_INODE_OPS         (XFSSTAT_END_TRANSACTIONS+7)
-       __uint32_t              xs_ig_attempts;
-       __uint32_t              xs_ig_found;
-       __uint32_t              xs_ig_frecycle;
-       __uint32_t              xs_ig_missed;
-       __uint32_t              xs_ig_dup;
-       __uint32_t              xs_ig_reclaims;
-       __uint32_t              xs_ig_attrchg;
+       uint32_t                xs_ig_attempts;
+       uint32_t                xs_ig_found;
+       uint32_t                xs_ig_frecycle;
+       uint32_t                xs_ig_missed;
+       uint32_t                xs_ig_dup;
+       uint32_t                xs_ig_reclaims;
+       uint32_t                xs_ig_attrchg;
 # define XFSSTAT_END_LOG_OPS           (XFSSTAT_END_INODE_OPS+5)
-       __uint32_t              xs_log_writes;
-       __uint32_t              xs_log_blocks;
-       __uint32_t              xs_log_noiclogs;
-       __uint32_t              xs_log_force;
-       __uint32_t              xs_log_force_sleep;
+       uint32_t                xs_log_writes;
+       uint32_t                xs_log_blocks;
+       uint32_t                xs_log_noiclogs;
+       uint32_t                xs_log_force;
+       uint32_t                xs_log_force_sleep;
 # define XFSSTAT_END_TAIL_PUSHING      (XFSSTAT_END_LOG_OPS+10)
-       __uint32_t              xs_try_logspace;
-       __uint32_t              xs_sleep_logspace;
-       __uint32_t              xs_push_ail;
-       __uint32_t              xs_push_ail_success;
-       __uint32_t              xs_push_ail_pushbuf;
-       __uint32_t              xs_push_ail_pinned;
-       __uint32_t              xs_push_ail_locked;
-       __uint32_t              xs_push_ail_flushing;
-       __uint32_t              xs_push_ail_restarts;
-       __uint32_t              xs_push_ail_flush;
+       uint32_t                xs_try_logspace;
+       uint32_t                xs_sleep_logspace;
+       uint32_t                xs_push_ail;
+       uint32_t                xs_push_ail_success;
+       uint32_t                xs_push_ail_pushbuf;
+       uint32_t                xs_push_ail_pinned;
+       uint32_t                xs_push_ail_locked;
+       uint32_t                xs_push_ail_flushing;
+       uint32_t                xs_push_ail_restarts;
+       uint32_t                xs_push_ail_flush;
 # define XFSSTAT_END_WRITE_CONVERT     (XFSSTAT_END_TAIL_PUSHING+2)
-       __uint32_t              xs_xstrat_quick;
-       __uint32_t              xs_xstrat_split;
+       uint32_t                xs_xstrat_quick;
+       uint32_t                xs_xstrat_split;
 # define XFSSTAT_END_READ_WRITE_OPS    (XFSSTAT_END_WRITE_CONVERT+2)
-       __uint32_t              xs_write_calls;
-       __uint32_t              xs_read_calls;
+       uint32_t                xs_write_calls;
+       uint32_t                xs_read_calls;
 # define XFSSTAT_END_ATTRIBUTE_OPS     (XFSSTAT_END_READ_WRITE_OPS+4)
-       __uint32_t              xs_attr_get;
-       __uint32_t              xs_attr_set;
-       __uint32_t              xs_attr_remove;
-       __uint32_t              xs_attr_list;
+       uint32_t                xs_attr_get;
+       uint32_t                xs_attr_set;
+       uint32_t                xs_attr_remove;
+       uint32_t                xs_attr_list;
 # define XFSSTAT_END_INODE_CLUSTER     (XFSSTAT_END_ATTRIBUTE_OPS+3)
-       __uint32_t              xs_iflush_count;
-       __uint32_t              xs_icluster_flushcnt;
-       __uint32_t              xs_icluster_flushinode;
+       uint32_t                xs_iflush_count;
+       uint32_t                xs_icluster_flushcnt;
+       uint32_t                xs_icluster_flushinode;
 # define XFSSTAT_END_VNODE_OPS         (XFSSTAT_END_INODE_CLUSTER+8)
-       __uint32_t              vn_active;      /* # vnodes not on free lists */
-       __uint32_t              vn_alloc;       /* # times vn_alloc called */
-       __uint32_t              vn_get;         /* # times vn_get called */
-       __uint32_t              vn_hold;        /* # times vn_hold called */
-       __uint32_t              vn_rele;        /* # times vn_rele called */
-       __uint32_t              vn_reclaim;     /* # times vn_reclaim called */
-       __uint32_t              vn_remove;      /* # times vn_remove called */
-       __uint32_t              vn_free;        /* # times vn_free called */
+       uint32_t                vn_active;      /* # vnodes not on free lists */
+       uint32_t                vn_alloc;       /* # times vn_alloc called */
+       uint32_t                vn_get;         /* # times vn_get called */
+       uint32_t                vn_hold;        /* # times vn_hold called */
+       uint32_t                vn_rele;        /* # times vn_rele called */
+       uint32_t                vn_reclaim;     /* # times vn_reclaim called */
+       uint32_t                vn_remove;      /* # times vn_remove called */
+       uint32_t                vn_free;        /* # times vn_free called */
 #define XFSSTAT_END_BUF                        (XFSSTAT_END_VNODE_OPS+9)
-       __uint32_t              xb_get;
-       __uint32_t              xb_create;
-       __uint32_t              xb_get_locked;
-       __uint32_t              xb_get_locked_waited;
-       __uint32_t              xb_busy_locked;
-       __uint32_t              xb_miss_locked;
-       __uint32_t              xb_page_retries;
-       __uint32_t              xb_page_found;
-       __uint32_t              xb_get_read;
+       uint32_t                xb_get;
+       uint32_t                xb_create;
+       uint32_t                xb_get_locked;
+       uint32_t                xb_get_locked_waited;
+       uint32_t                xb_busy_locked;
+       uint32_t                xb_miss_locked;
+       uint32_t                xb_page_retries;
+       uint32_t                xb_page_found;
+       uint32_t                xb_get_read;
 /* Version 2 btree counters */
 #define XFSSTAT_END_ABTB_V2            (XFSSTAT_END_BUF + __XBTS_MAX)
-       __uint32_t              xs_abtb_2[__XBTS_MAX];
+       uint32_t                xs_abtb_2[__XBTS_MAX];
 #define XFSSTAT_END_ABTC_V2            (XFSSTAT_END_ABTB_V2 + __XBTS_MAX)
-       __uint32_t              xs_abtc_2[__XBTS_MAX];
+       uint32_t                xs_abtc_2[__XBTS_MAX];
 #define XFSSTAT_END_BMBT_V2            (XFSSTAT_END_ABTC_V2 + __XBTS_MAX)
-       __uint32_t              xs_bmbt_2[__XBTS_MAX];
+       uint32_t                xs_bmbt_2[__XBTS_MAX];
 #define XFSSTAT_END_IBT_V2             (XFSSTAT_END_BMBT_V2 + __XBTS_MAX)
-       __uint32_t              xs_ibt_2[__XBTS_MAX];
+       uint32_t                xs_ibt_2[__XBTS_MAX];
 #define XFSSTAT_END_FIBT_V2            (XFSSTAT_END_IBT_V2 + __XBTS_MAX)
-       __uint32_t              xs_fibt_2[__XBTS_MAX];
+       uint32_t                xs_fibt_2[__XBTS_MAX];
 #define XFSSTAT_END_RMAP_V2            (XFSSTAT_END_FIBT_V2 + __XBTS_MAX)
-       __uint32_t              xs_rmap_2[__XBTS_MAX];
+       uint32_t                xs_rmap_2[__XBTS_MAX];
 #define XFSSTAT_END_REFCOUNT           (XFSSTAT_END_RMAP_V2 + __XBTS_MAX)
-       __uint32_t              xs_refcbt_2[__XBTS_MAX];
+       uint32_t                xs_refcbt_2[__XBTS_MAX];
 #define XFSSTAT_END_XQMSTAT            (XFSSTAT_END_REFCOUNT + 6)
-       __uint32_t              xs_qm_dqreclaims;
-       __uint32_t              xs_qm_dqreclaim_misses;
-       __uint32_t              xs_qm_dquot_dups;
-       __uint32_t              xs_qm_dqcachemisses;
-       __uint32_t              xs_qm_dqcachehits;
-       __uint32_t              xs_qm_dqwants;
+       uint32_t                xs_qm_dqreclaims;
+       uint32_t                xs_qm_dqreclaim_misses;
+       uint32_t                xs_qm_dquot_dups;
+       uint32_t                xs_qm_dqcachemisses;
+       uint32_t                xs_qm_dqcachehits;
+       uint32_t                xs_qm_dqwants;
 #define XFSSTAT_END_QM                 (XFSSTAT_END_XQMSTAT+2)
-       __uint32_t              xs_qm_dquot;
-       __uint32_t              xs_qm_dquot_unused;
+       uint32_t                xs_qm_dquot;
+       uint32_t                xs_qm_dquot_unused;
 /* Extra precision counters */
-       __uint64_t              xs_xstrat_bytes;
-       __uint64_t              xs_write_bytes;
-       __uint64_t              xs_read_bytes;
+       uint64_t                xs_xstrat_bytes;
+       uint64_t                xs_write_bytes;
+       uint64_t                xs_read_bytes;
 };
 
 struct xfsstats {
@@ -186,7 +186,7 @@ struct xfsstats {
  * simple wrapper for getting the array index of s struct member offset
  */
 #define XFS_STATS_CALC_INDEX(member)   \
-       (offsetof(struct __xfsstats, member) / (int)sizeof(__uint32_t))
+       (offsetof(struct __xfsstats, member) / (int)sizeof(uint32_t))
 
 
 int xfs_stats_format(struct xfsstats __percpu *stats, char *buf);
index 455a575f101db1f22b8c8c0aca247d627f82ea4c..a19aab897c9b3587465a10b19de24286e41f3a39 100644 (file)
@@ -196,7 +196,7 @@ xfs_parseargs(
        int                     dsunit = 0;
        int                     dswidth = 0;
        int                     iosize = 0;
-       __uint8_t               iosizelog = 0;
+       uint8_t                 iosizelog = 0;
 
        /*
         * set up the mount name first so all the errors will refer to the
@@ -556,7 +556,7 @@ xfs_showargs(
 
        return 0;
 }
-static __uint64_t
+static uint64_t
 xfs_max_file_offset(
        unsigned int            blockshift)
 {
@@ -587,7 +587,7 @@ xfs_max_file_offset(
 # endif
 #endif
 
-       return (((__uint64_t)pagefactor) << bitshift) - 1;
+       return (((uint64_t)pagefactor) << bitshift) - 1;
 }
 
 /*
@@ -622,7 +622,7 @@ xfs_set_inode_alloc(
         * the max inode percentage.  Used only for inode32.
         */
        if (mp->m_maxicount) {
-               __uint64_t      icount;
+               uint64_t        icount;
 
                icount = sbp->sb_dblocks * sbp->sb_imax_pct;
                do_div(icount, 100);
@@ -1088,12 +1088,12 @@ xfs_fs_statfs(
        struct xfs_mount        *mp = XFS_M(dentry->d_sb);
        xfs_sb_t                *sbp = &mp->m_sb;
        struct xfs_inode        *ip = XFS_I(d_inode(dentry));
-       __uint64_t              fakeinos, id;
-       __uint64_t              icount;
-       __uint64_t              ifree;
-       __uint64_t              fdblocks;
+       uint64_t                fakeinos, id;
+       uint64_t                icount;
+       uint64_t                ifree;
+       uint64_t                fdblocks;
        xfs_extlen_t            lsize;
-       __int64_t               ffree;
+       int64_t                 ffree;
 
        statp->f_type = XFS_SB_MAGIC;
        statp->f_namelen = MAXNAMELEN - 1;
@@ -1116,7 +1116,7 @@ xfs_fs_statfs(
        statp->f_bavail = statp->f_bfree;
 
        fakeinos = statp->f_bfree << sbp->sb_inopblog;
-       statp->f_files = MIN(icount + fakeinos, (__uint64_t)XFS_MAXINUMBER);
+       statp->f_files = MIN(icount + fakeinos, (uint64_t)XFS_MAXINUMBER);
        if (mp->m_maxicount)
                statp->f_files = min_t(typeof(statp->f_files),
                                        statp->f_files,
@@ -1129,7 +1129,7 @@ xfs_fs_statfs(
 
        /* make sure statp->f_ffree does not underflow */
        ffree = statp->f_files - (icount - ifree);
-       statp->f_ffree = max_t(__int64_t, ffree, 0);
+       statp->f_ffree = max_t(int64_t, ffree, 0);
 
 
        if ((ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
@@ -1142,7 +1142,7 @@ xfs_fs_statfs(
 STATIC void
 xfs_save_resvblks(struct xfs_mount *mp)
 {
-       __uint64_t resblks = 0;
+       uint64_t resblks = 0;
 
        mp->m_resblks_save = mp->m_resblks;
        xfs_reserve_blocks(mp, &resblks, NULL);
@@ -1151,7 +1151,7 @@ xfs_save_resvblks(struct xfs_mount *mp)
 STATIC void
 xfs_restore_resvblks(struct xfs_mount *mp)
 {
-       __uint64_t resblks;
+       uint64_t resblks;
 
        if (mp->m_resblks_save) {
                resblks = mp->m_resblks_save;
index a560bfd392c101f78aa35397dc077bf71ba78239..bcc3cdf8e1c5da7797463bf6023171860268f3d6 100644 (file)
@@ -251,7 +251,7 @@ TRACE_EVENT(xfs_iext_insert,
                  __print_flags(__entry->bmap_state, "|", XFS_BMAP_EXT_FLAGS),
                  (long)__entry->idx,
                  __entry->startoff,
-                 (__int64_t)__entry->startblock,
+                 (int64_t)__entry->startblock,
                  __entry->blockcount,
                  __entry->state,
                  (char *)__entry->caller_ip)
@@ -295,7 +295,7 @@ DECLARE_EVENT_CLASS(xfs_bmap_class,
                  __print_flags(__entry->bmap_state, "|", XFS_BMAP_EXT_FLAGS),
                  (long)__entry->idx,
                  __entry->startoff,
-                 (__int64_t)__entry->startblock,
+                 (int64_t)__entry->startblock,
                  __entry->blockcount,
                  __entry->state,
                  (char *)__entry->caller_ip)
@@ -1281,7 +1281,7 @@ DECLARE_EVENT_CLASS(xfs_imap_class,
                  __entry->count,
                  __print_symbolic(__entry->type, XFS_IO_TYPES),
                  __entry->startoff,
-                 (__int64_t)__entry->startblock,
+                 (int64_t)__entry->startblock,
                  __entry->blockcount)
 )
 
@@ -2039,7 +2039,7 @@ DECLARE_EVENT_CLASS(xfs_log_recover_buf_item_class,
        TP_ARGS(log, buf_f),
        TP_STRUCT__entry(
                __field(dev_t, dev)
-               __field(__int64_t, blkno)
+               __field(int64_t, blkno)
                __field(unsigned short, len)
                __field(unsigned short, flags)
                __field(unsigned short, size)
@@ -2088,7 +2088,7 @@ DECLARE_EVENT_CLASS(xfs_log_recover_ino_item_class,
                __field(int, fields)
                __field(unsigned short, asize)
                __field(unsigned short, dsize)
-               __field(__int64_t, blkno)
+               __field(int64_t, blkno)
                __field(int, len)
                __field(int, boffset)
        ),
@@ -3238,8 +3238,8 @@ DECLARE_EVENT_CLASS(xfs_fsmap_class,
                __field(xfs_agnumber_t, agno)
                __field(xfs_fsblock_t, bno)
                __field(xfs_filblks_t, len)
-               __field(__uint64_t, owner)
-               __field(__uint64_t, offset)
+               __field(uint64_t, owner)
+               __field(uint64_t, offset)
                __field(unsigned int, flags)
        ),
        TP_fast_assign(
@@ -3279,9 +3279,9 @@ DECLARE_EVENT_CLASS(xfs_getfsmap_class,
                __field(dev_t, keydev)
                __field(xfs_daddr_t, block)
                __field(xfs_daddr_t, len)
-               __field(__uint64_t, owner)
-               __field(__uint64_t, offset)
-               __field(__uint64_t, flags)
+               __field(uint64_t, owner)
+               __field(uint64_t, offset)
+               __field(uint64_t, flags)
        ),
        TP_fast_assign(
                __entry->dev = mp->m_super->s_dev;
index 82bb61e330d9123c290678bb4b2f9638872976bb..6bdad6f5893453d534b147caa1ba52fd2fb6ec4c 100644 (file)
@@ -245,7 +245,7 @@ struct xfs_rud_log_item *xfs_trans_get_rud(struct xfs_trans *tp,
                struct xfs_rui_log_item *ruip);
 int xfs_trans_log_finish_rmap_update(struct xfs_trans *tp,
                struct xfs_rud_log_item *rudp, 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);
 
index 9ead064b5e90ae34507c450cfa24988c8bc669c1..9b577beb43d7c6dfcba6101cb655597a1ebcd06c 100644 (file)
@@ -96,7 +96,7 @@ xfs_trans_log_finish_rmap_update(
        struct xfs_trans                *tp,
        struct xfs_rud_log_item         *rudp,
        enum xfs_rmap_intent_type       type,
-       __uint64_t                      owner,
+       uint64_t                        owner,
        int                             whichfork,
        xfs_fileoff_t                   startoff,
        xfs_fsblock_t                   startblock,