summaryrefslogtreecommitdiffstats
path: root/meta-filesystems/recipes-utils/xfsprogs/files
diff options
context:
space:
mode:
Diffstat (limited to 'meta-filesystems/recipes-utils/xfsprogs/files')
-rw-r--r--meta-filesystems/recipes-utils/xfsprogs/files/0001-build-Check-for-sync_file_range-libc-function.patch82
-rw-r--r--meta-filesystems/recipes-utils/xfsprogs/files/0001-xfs-remove-double-underscore-integer-types.patch2082
-rw-r--r--meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch3800
-rw-r--r--meta-filesystems/recipes-utils/xfsprogs/files/remove_flags_from_build_flags.patch12
-rw-r--r--meta-filesystems/recipes-utils/xfsprogs/files/xfsprogs-4.12.0-fix_musl.patch117
5 files changed, 88 insertions, 6005 deletions
diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/0001-build-Check-for-sync_file_range-libc-function.patch b/meta-filesystems/recipes-utils/xfsprogs/files/0001-build-Check-for-sync_file_range-libc-function.patch
new file mode 100644
index 000000000..d8ff55531
--- /dev/null
+++ b/meta-filesystems/recipes-utils/xfsprogs/files/0001-build-Check-for-sync_file_range-libc-function.patch
@@ -0,0 +1,82 @@
1From ae7172194d3fbb563ff8bbe7c02d34f1bd0e5ec9 Mon Sep 17 00:00:00 2001
2From: Khem Raj <raj.khem@gmail.com>
3Date: Wed, 31 Jan 2018 21:28:53 -0800
4Subject: [PATCH] build: Check for sync_file_range libc function
5
6glibc 2.27 now has sync_file_range()
7
8Signed-off-by: Khem Raj <raj.khem@gmail.com>
9---
10Upstream-Status: Pending
11
12 include/builddefs.in | 1 +
13 io/Makefile | 5 ++++-
14 io/io.h | 2 +-
15 io/sync_file_range.c | 3 +++
16 4 files changed, 9 insertions(+), 2 deletions(-)
17
18diff --git a/include/builddefs.in b/include/builddefs.in
19index 92d5076..504225a 100644
20--- a/include/builddefs.in
21+++ b/include/builddefs.in
22@@ -105,6 +105,7 @@ HAVE_FIEMAP = @have_fiemap@
23 HAVE_PREADV = @have_preadv@
24 HAVE_PWRITEV2 = @have_pwritev2@
25 HAVE_COPY_FILE_RANGE = @have_copy_file_range@
26+HAVE_NR_COPY_FILE_RANGE = @have_nr_copy_file_range@
27 HAVE_SYNC_FILE_RANGE = @have_sync_file_range@
28 HAVE_SYNCFS = @have_syncfs@
29 HAVE_READDIR = @have_readdir@
30diff --git a/io/Makefile b/io/Makefile
31index 6725936..1876e95 100644
32--- a/io/Makefile
33+++ b/io/Makefile
34@@ -59,10 +59,13 @@ CFILES += inject.c resblks.c
35 LCFLAGS += -DHAVE_INJECT -DHAVE_RESBLKS
36 endif
37
38-ifeq ($(HAVE_COPY_FILE_RANGE),yes)
39+ifeq ($(HAVE_NR_COPY_FILE_RANGE),yes)
40 CFILES += copy_file_range.c
41+LCFLAGS += -DHAVE_NR_COPY_FILE_RANGE
42+ifeq ($(HAVE_COPY_FILE_RANGE),yes)
43 LCFLAGS += -DHAVE_COPY_FILE_RANGE
44 endif
45+endif
46
47 ifeq ($(HAVE_SYNC_FILE_RANGE),yes)
48 CFILES += sync_file_range.c
49diff --git a/io/io.h b/io/io.h
50index 3862985..79ddc7b 100644
51--- a/io/io.h
52+++ b/io/io.h
53@@ -158,7 +158,7 @@ extern void fiemap_init(void);
54 #define fiemap_init() do { } while (0)
55 #endif
56
57-#ifdef HAVE_COPY_FILE_RANGE
58+#if defined(HAVE_NR_COPY_FILE_RANGE) && !defined(HAVE_COPY_FILE_RANGE)
59 extern void copy_range_init(void);
60 #else
61 #define copy_range_init() do { } while (0)
62diff --git a/io/sync_file_range.c b/io/sync_file_range.c
63index 7e4f3e6..aafea01 100644
64--- a/io/sync_file_range.c
65+++ b/io/sync_file_range.c
66@@ -16,6 +16,7 @@
67 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
68 */
69
70+#ifndef HAVE_COPY_FILE_RANGE
71 #include "command.h"
72 #include "input.h"
73 #include "init.h"
74@@ -104,3 +105,5 @@ sync_range_init(void)
75
76 add_command(&sync_range_cmd);
77 }
78+
79+#endif
80--
812.16.1
82
diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfs-remove-double-underscore-integer-types.patch b/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfs-remove-double-underscore-integer-types.patch
deleted file mode 100644
index a47c48707..000000000
--- a/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfs-remove-double-underscore-integer-types.patch
+++ /dev/null
@@ -1,2082 +0,0 @@
1From 4a492e72515509ee702286a42afe7d8f89d37636 Mon Sep 17 00:00:00 2001
2From: "Darrick J. Wong" <darrick.wong@oracle.com>
3Date: Mon, 31 Jul 2017 15:08:10 -0500
4Subject: [PATCH] xfs: remove double-underscore integer types
5
6Source kernel commit: c8ce540db5f67d254aafb14b5d76422c62a906df
7
8This is a purely mechanical patch that removes the private
9__{u,}int{8,16,32,64}_t typedefs in favor of using the system
10{u,}int{8,16,32,64}_t typedefs. This is the sed script used to perform
11the transformation and fix the resulting whitespace and indentation
12errors:
13
14s/typedef\t__uint8_t/typedef __uint8_t\t/g
15s/typedef\t__uint/typedef __uint/g
16s/typedef\t__int\([0-9]*\)_t/typedef int\1_t\t/g
17s/__uint8_t\t/__uint8_t\t\t/g
18s/__uint/uint/g
19s/__int\([0-9]*\)_t\t/__int\1_t\t\t/g
20s/__int/int/g
21/^typedef.*int[0-9]*_t;$/d
22
23Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
24Reviewed-by: Christoph Hellwig <hch@lst.de>
25Signed-off-by: Eric Sandeen <sandeen@sandeen.net>
26---
27 libxfs/libxfs_priv.h | 1 +
28 libxfs/xfs_alloc_btree.c | 20 ++--
29 libxfs/xfs_attr_remote.c | 8 +-
30 libxfs/xfs_attr_sf.h | 10 +-
31 libxfs/xfs_bit.h | 24 ++---
32 libxfs/xfs_bmap_btree.c | 8 +-
33 libxfs/xfs_btree.c | 22 ++--
34 libxfs/xfs_btree.h | 18 ++--
35 libxfs/xfs_cksum.h | 16 +--
36 libxfs/xfs_da_btree.c | 2 +-
37 libxfs/xfs_da_btree.h | 8 +-
38 libxfs/xfs_da_format.c | 28 ++---
39 libxfs/xfs_da_format.h | 64 +++++------
40 libxfs/xfs_dir2.h | 8 +-
41 libxfs/xfs_dir2_leaf.c | 12 +--
42 libxfs/xfs_dir2_priv.h | 2 +-
43 libxfs/xfs_dir2_sf.c | 4 +-
44 libxfs/xfs_format.h | 112 +++++++++----------
45 libxfs/xfs_fs.h | 12 +--
46 libxfs/xfs_ialloc.c | 6 +-
47 libxfs/xfs_ialloc_btree.c | 4 +-
48 libxfs/xfs_inode_buf.c | 2 +-
49 libxfs/xfs_inode_buf.h | 28 ++---
50 libxfs/xfs_log_format.h | 256 ++++++++++++++++++++++----------------------
51 libxfs/xfs_quota_defs.h | 4 +-
52 libxfs/xfs_refcount_btree.c | 8 +-
53 libxfs/xfs_rmap.c | 8 +-
54 libxfs/xfs_rmap.h | 8 +-
55 libxfs/xfs_rmap_btree.c | 30 +++---
56 libxfs/xfs_rtbitmap.c | 2 +-
57 libxfs/xfs_sb.c | 4 +-
58 libxfs/xfs_types.h | 46 ++++----
59 32 files changed, 393 insertions(+), 392 deletions(-)
60
61diff --git a/libxfs/libxfs_priv.h b/libxfs/libxfs_priv.h
62index 0b4c4890..b3cc7e53 100644
63--- a/libxfs/libxfs_priv.h
64+++ b/libxfs/libxfs_priv.h
65@@ -504,5 +504,6 @@ bool xfs_log_check_lsn(struct xfs_mount *, xfs_lsn_t);
66 #define XFS_STATS_INC_OFF(mp, off)
67 #define XFS_STATS_ADD_OFF(mp, off, val)
68
69+typedef unsigned char u8;
70
71 #endif /* __LIBXFS_INTERNAL_XFS_H__ */
72diff --git a/libxfs/xfs_alloc_btree.c b/libxfs/xfs_alloc_btree.c
73index e11d89a3..8e77e6e3 100644
74--- a/libxfs/xfs_alloc_btree.c
75+++ b/libxfs/xfs_alloc_btree.c
76@@ -251,7 +251,7 @@ xfs_allocbt_init_ptr_from_cur(
77 ptr->s = agf->agf_roots[cur->bc_btnum];
78 }
79
80-STATIC __int64_t
81+STATIC int64_t
82 xfs_bnobt_key_diff(
83 struct xfs_btree_cur *cur,
84 union xfs_btree_key *key)
85@@ -259,42 +259,42 @@ xfs_bnobt_key_diff(
86 xfs_alloc_rec_incore_t *rec = &cur->bc_rec.a;
87 xfs_alloc_key_t *kp = &key->alloc;
88
89- return (__int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;
90+ return (int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;
91 }
92
93-STATIC __int64_t
94+STATIC int64_t
95 xfs_cntbt_key_diff(
96 struct xfs_btree_cur *cur,
97 union xfs_btree_key *key)
98 {
99 xfs_alloc_rec_incore_t *rec = &cur->bc_rec.a;
100 xfs_alloc_key_t *kp = &key->alloc;
101- __int64_t diff;
102+ int64_t diff;
103
104- diff = (__int64_t)be32_to_cpu(kp->ar_blockcount) - rec->ar_blockcount;
105+ diff = (int64_t)be32_to_cpu(kp->ar_blockcount) - rec->ar_blockcount;
106 if (diff)
107 return diff;
108
109- return (__int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;
110+ return (int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;
111 }
112
113-STATIC __int64_t
114+STATIC int64_t
115 xfs_bnobt_diff_two_keys(
116 struct xfs_btree_cur *cur,
117 union xfs_btree_key *k1,
118 union xfs_btree_key *k2)
119 {
120- return (__int64_t)be32_to_cpu(k1->alloc.ar_startblock) -
121+ return (int64_t)be32_to_cpu(k1->alloc.ar_startblock) -
122 be32_to_cpu(k2->alloc.ar_startblock);
123 }
124
125-STATIC __int64_t
126+STATIC int64_t
127 xfs_cntbt_diff_two_keys(
128 struct xfs_btree_cur *cur,
129 union xfs_btree_key *k1,
130 union xfs_btree_key *k2)
131 {
132- __int64_t diff;
133+ int64_t diff;
134
135 diff = be32_to_cpu(k1->alloc.ar_blockcount) -
136 be32_to_cpu(k2->alloc.ar_blockcount);
137diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c
138index abe17052..1f25e363 100644
139--- a/libxfs/xfs_attr_remote.c
140+++ b/libxfs/xfs_attr_remote.c
141@@ -248,7 +248,7 @@ xfs_attr_rmtval_copyout(
142 xfs_ino_t ino,
143 int *offset,
144 int *valuelen,
145- __uint8_t **dst)
146+ uint8_t **dst)
147 {
148 char *src = bp->b_addr;
149 xfs_daddr_t bno = bp->b_bn;
150@@ -296,7 +296,7 @@ xfs_attr_rmtval_copyin(
151 xfs_ino_t ino,
152 int *offset,
153 int *valuelen,
154- __uint8_t **src)
155+ uint8_t **src)
156 {
157 char *dst = bp->b_addr;
158 xfs_daddr_t bno = bp->b_bn;
159@@ -350,7 +350,7 @@ xfs_attr_rmtval_get(
160 struct xfs_mount *mp = args->dp->i_mount;
161 struct xfs_buf *bp;
162 xfs_dablk_t lblkno = args->rmtblkno;
163- __uint8_t *dst = args->value;
164+ uint8_t *dst = args->value;
165 int valuelen;
166 int nmap;
167 int error;
168@@ -416,7 +416,7 @@ xfs_attr_rmtval_set(
169 struct xfs_bmbt_irec map;
170 xfs_dablk_t lblkno;
171 xfs_fileoff_t lfileoff = 0;
172- __uint8_t *src = args->value;
173+ uint8_t *src = args->value;
174 int blkcnt;
175 int valuelen;
176 int nmap;
177diff --git a/libxfs/xfs_attr_sf.h b/libxfs/xfs_attr_sf.h
178index 90928bbe..afd684ae 100644
179--- a/libxfs/xfs_attr_sf.h
180+++ b/libxfs/xfs_attr_sf.h
181@@ -31,10 +31,10 @@ typedef struct xfs_attr_sf_entry xfs_attr_sf_entry_t;
182 * We generate this then sort it, attr_list() must return things in hash-order.
183 */
184 typedef struct xfs_attr_sf_sort {
185- __uint8_t entno; /* entry number in original list */
186- __uint8_t namelen; /* length of name value (no null) */
187- __uint8_t valuelen; /* length of value */
188- __uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */
189+ uint8_t entno; /* entry number in original list */
190+ uint8_t namelen; /* length of name value (no null) */
191+ uint8_t valuelen; /* length of value */
192+ uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */
193 xfs_dahash_t hash; /* this entry's hash value */
194 unsigned char *name; /* name value, pointer into buffer */
195 } xfs_attr_sf_sort_t;
196@@ -42,7 +42,7 @@ typedef struct xfs_attr_sf_sort {
197 #define XFS_ATTR_SF_ENTSIZE_BYNAME(nlen,vlen) /* space name/value uses */ \
198 (((int)sizeof(xfs_attr_sf_entry_t)-1 + (nlen)+(vlen)))
199 #define XFS_ATTR_SF_ENTSIZE_MAX /* max space for name&value */ \
200- ((1 << (NBBY*(int)sizeof(__uint8_t))) - 1)
201+ ((1 << (NBBY*(int)sizeof(uint8_t))) - 1)
202 #define XFS_ATTR_SF_ENTSIZE(sfep) /* space an entry uses */ \
203 ((int)sizeof(xfs_attr_sf_entry_t)-1 + (sfep)->namelen+(sfep)->valuelen)
204 #define XFS_ATTR_SF_NEXTENTRY(sfep) /* next entry in struct */ \
205diff --git a/libxfs/xfs_bit.h b/libxfs/xfs_bit.h
206index e1649c0d..61c6b202 100644
207--- a/libxfs/xfs_bit.h
208+++ b/libxfs/xfs_bit.h
209@@ -25,47 +25,47 @@
210 /*
211 * masks with n high/low bits set, 64-bit values
212 */
213-static inline __uint64_t xfs_mask64hi(int n)
214+static inline uint64_t xfs_mask64hi(int n)
215 {
216- return (__uint64_t)-1 << (64 - (n));
217+ return (uint64_t)-1 << (64 - (n));
218 }
219-static inline __uint32_t xfs_mask32lo(int n)
220+static inline uint32_t xfs_mask32lo(int n)
221 {
222- return ((__uint32_t)1 << (n)) - 1;
223+ return ((uint32_t)1 << (n)) - 1;
224 }
225-static inline __uint64_t xfs_mask64lo(int n)
226+static inline uint64_t xfs_mask64lo(int n)
227 {
228- return ((__uint64_t)1 << (n)) - 1;
229+ return ((uint64_t)1 << (n)) - 1;
230 }
231
232 /* Get high bit set out of 32-bit argument, -1 if none set */
233-static inline int xfs_highbit32(__uint32_t v)
234+static inline int xfs_highbit32(uint32_t v)
235 {
236 return fls(v) - 1;
237 }
238
239 /* Get high bit set out of 64-bit argument, -1 if none set */
240-static inline int xfs_highbit64(__uint64_t v)
241+static inline int xfs_highbit64(uint64_t v)
242 {
243 return fls64(v) - 1;
244 }
245
246 /* Get low bit set out of 32-bit argument, -1 if none set */
247-static inline int xfs_lowbit32(__uint32_t v)
248+static inline int xfs_lowbit32(uint32_t v)
249 {
250 return ffs(v) - 1;
251 }
252
253 /* Get low bit set out of 64-bit argument, -1 if none set */
254-static inline int xfs_lowbit64(__uint64_t v)
255+static inline int xfs_lowbit64(uint64_t v)
256 {
257- __uint32_t w = (__uint32_t)v;
258+ uint32_t w = (uint32_t)v;
259 int n = 0;
260
261 if (w) { /* lower bits */
262 n = ffs(w);
263 } else { /* upper bits */
264- w = (__uint32_t)(v >> 32);
265+ w = (uint32_t)(v >> 32);
266 if (w) {
267 n = ffs(w);
268 if (n)
269diff --git a/libxfs/xfs_bmap_btree.c b/libxfs/xfs_bmap_btree.c
270index c48cbec1..9ee40d8b 100644
271--- a/libxfs/xfs_bmap_btree.c
272+++ b/libxfs/xfs_bmap_btree.c
273@@ -91,8 +91,8 @@ xfs_bmdr_to_bmbt(
274 */
275 STATIC void
276 __xfs_bmbt_get_all(
277- __uint64_t l0,
278- __uint64_t l1,
279+ uint64_t l0,
280+ uint64_t l1,
281 xfs_bmbt_irec_t *s)
282 {
283 int ext_flag;
284@@ -585,12 +585,12 @@ xfs_bmbt_init_ptr_from_cur(
285 ptr->l = 0;
286 }
287
288-STATIC __int64_t
289+STATIC int64_t
290 xfs_bmbt_key_diff(
291 struct xfs_btree_cur *cur,
292 union xfs_btree_key *key)
293 {
294- return (__int64_t)be64_to_cpu(key->bmbt.br_startoff) -
295+ return (int64_t)be64_to_cpu(key->bmbt.br_startoff) -
296 cur->bc_rec.b.br_startoff;
297 }
298
299diff --git a/libxfs/xfs_btree.c b/libxfs/xfs_btree.c
300index 3d293520..56b50a5b 100644
301--- a/libxfs/xfs_btree.c
302+++ b/libxfs/xfs_btree.c
303@@ -39,7 +39,7 @@ kmem_zone_t *xfs_btree_cur_zone;
304 /*
305 * Btree magic numbers.
306 */
307-static const __uint32_t xfs_magics[2][XFS_BTNUM_MAX] = {
308+static const uint32_t xfs_magics[2][XFS_BTNUM_MAX] = {
309 { XFS_ABTB_MAGIC, XFS_ABTC_MAGIC, 0, XFS_BMAP_MAGIC, XFS_IBT_MAGIC,
310 XFS_FIBT_MAGIC, 0 },
311 { XFS_ABTB_CRC_MAGIC, XFS_ABTC_CRC_MAGIC, XFS_RMAP_CRC_MAGIC,
312@@ -47,12 +47,12 @@ static const __uint32_t xfs_magics[2][XFS_BTNUM_MAX] = {
313 XFS_REFC_CRC_MAGIC }
314 };
315
316-__uint32_t
317+uint32_t
318 xfs_btree_magic(
319 int crc,
320 xfs_btnum_t btnum)
321 {
322- __uint32_t magic = xfs_magics[crc][btnum];
323+ uint32_t magic = xfs_magics[crc][btnum];
324
325 /* Ensure we asked for crc for crc-only magics. */
326 ASSERT(magic != 0);
327@@ -774,14 +774,14 @@ xfs_btree_lastrec(
328 */
329 void
330 xfs_btree_offsets(
331- __int64_t fields, /* bitmask of fields */
332+ int64_t fields, /* bitmask of fields */
333 const short *offsets, /* table of field offsets */
334 int nbits, /* number of bits to inspect */
335 int *first, /* output: first byte offset */
336 int *last) /* output: last byte offset */
337 {
338 int i; /* current bit number */
339- __int64_t imask; /* mask for current bit number */
340+ int64_t imask; /* mask for current bit number */
341
342 ASSERT(fields != 0);
343 /*
344@@ -1842,7 +1842,7 @@ xfs_btree_lookup(
345 int *stat) /* success/failure */
346 {
347 struct xfs_btree_block *block; /* current btree block */
348- __int64_t diff; /* difference for the current key */
349+ int64_t diff; /* difference for the current key */
350 int error; /* error return value */
351 int keyno; /* current key number */
352 int level; /* level in the btree */
353@@ -4435,7 +4435,7 @@ xfs_btree_visit_blocks(
354 * recovery completion writes the changes to disk.
355 */
356 struct xfs_btree_block_change_owner_info {
357- __uint64_t new_owner;
358+ uint64_t new_owner;
359 struct list_head *buffer_list;
360 };
361
362@@ -4481,7 +4481,7 @@ xfs_btree_block_change_owner(
363 int
364 xfs_btree_change_owner(
365 struct xfs_btree_cur *cur,
366- __uint64_t new_owner,
367+ uint64_t new_owner,
368 struct list_head *buffer_list)
369 {
370 struct xfs_btree_block_change_owner_info bbcoi;
371@@ -4585,7 +4585,7 @@ xfs_btree_simple_query_range(
372 {
373 union xfs_btree_rec *recp;
374 union xfs_btree_key rec_key;
375- __int64_t diff;
376+ int64_t diff;
377 int stat;
378 bool firstrec = true;
379 int error;
380@@ -4682,8 +4682,8 @@ xfs_btree_overlapped_query_range(
381 union xfs_btree_key *hkp;
382 union xfs_btree_rec *recp;
383 struct xfs_btree_block *block;
384- __int64_t ldiff;
385- __int64_t hdiff;
386+ int64_t ldiff;
387+ int64_t hdiff;
388 int level;
389 struct xfs_buf *bp;
390 int i;
391diff --git a/libxfs/xfs_btree.h b/libxfs/xfs_btree.h
392index 05cf35b5..3c1fed23 100644
393--- a/libxfs/xfs_btree.h
394+++ b/libxfs/xfs_btree.h
395@@ -76,7 +76,7 @@ union xfs_btree_rec {
396 #define XFS_BTNUM_RMAP ((xfs_btnum_t)XFS_BTNUM_RMAPi)
397 #define XFS_BTNUM_REFC ((xfs_btnum_t)XFS_BTNUM_REFCi)
398
399-__uint32_t xfs_btree_magic(int crc, xfs_btnum_t btnum);
400+uint32_t xfs_btree_magic(int crc, xfs_btnum_t btnum);
401
402 /*
403 * For logging record fields.
404@@ -150,14 +150,14 @@ struct xfs_btree_ops {
405 union xfs_btree_rec *rec);
406
407 /* difference between key value and cursor value */
408- __int64_t (*key_diff)(struct xfs_btree_cur *cur,
409+ int64_t (*key_diff)(struct xfs_btree_cur *cur,
410 union xfs_btree_key *key);
411
412 /*
413 * Difference between key2 and key1 -- positive if key1 > key2,
414 * negative if key1 < key2, and zero if equal.
415 */
416- __int64_t (*diff_two_keys)(struct xfs_btree_cur *cur,
417+ int64_t (*diff_two_keys)(struct xfs_btree_cur *cur,
418 union xfs_btree_key *key1,
419 union xfs_btree_key *key2);
420
421@@ -213,11 +213,11 @@ typedef struct xfs_btree_cur
422 union xfs_btree_irec bc_rec; /* current insert/search record value */
423 struct xfs_buf *bc_bufs[XFS_BTREE_MAXLEVELS]; /* buf ptr per level */
424 int bc_ptrs[XFS_BTREE_MAXLEVELS]; /* key/record # */
425- __uint8_t bc_ra[XFS_BTREE_MAXLEVELS]; /* readahead bits */
426+ uint8_t bc_ra[XFS_BTREE_MAXLEVELS]; /* readahead bits */
427 #define XFS_BTCUR_LEFTRA 1 /* left sibling has been read-ahead */
428 #define XFS_BTCUR_RIGHTRA 2 /* right sibling has been read-ahead */
429- __uint8_t bc_nlevels; /* number of levels in the tree */
430- __uint8_t bc_blocklog; /* log2(blocksize) of btree blocks */
431+ uint8_t bc_nlevels; /* number of levels in the tree */
432+ uint8_t bc_blocklog; /* log2(blocksize) of btree blocks */
433 xfs_btnum_t bc_btnum; /* identifies which btree type */
434 int bc_statoff; /* offset of btre stats array */
435 union {
436@@ -330,7 +330,7 @@ xfs_btree_islastblock(
437 */
438 void
439 xfs_btree_offsets(
440- __int64_t fields, /* bitmask of fields */
441+ int64_t fields, /* bitmask of fields */
442 const short *offsets,/* table of field offsets */
443 int nbits, /* number of bits to inspect */
444 int *first, /* output: first byte offset */
445@@ -408,7 +408,7 @@ int xfs_btree_new_iroot(struct xfs_btree_cur *, int *, int *);
446 int xfs_btree_insert(struct xfs_btree_cur *, int *);
447 int xfs_btree_delete(struct xfs_btree_cur *, int *);
448 int xfs_btree_get_rec(struct xfs_btree_cur *, union xfs_btree_rec **, int *);
449-int xfs_btree_change_owner(struct xfs_btree_cur *cur, __uint64_t new_owner,
450+int xfs_btree_change_owner(struct xfs_btree_cur *cur, uint64_t new_owner,
451 struct list_head *buffer_list);
452
453 /*
454@@ -434,7 +434,7 @@ static inline int xfs_btree_get_numrecs(struct xfs_btree_block *block)
455 }
456
457 static inline void xfs_btree_set_numrecs(struct xfs_btree_block *block,
458- __uint16_t numrecs)
459+ uint16_t numrecs)
460 {
461 block->bb_numrecs = cpu_to_be16(numrecs);
462 }
463diff --git a/libxfs/xfs_cksum.h b/libxfs/xfs_cksum.h
464index a416c7cb..8211f48b 100644
465--- a/libxfs/xfs_cksum.h
466+++ b/libxfs/xfs_cksum.h
467@@ -1,7 +1,7 @@
468 #ifndef _XFS_CKSUM_H
469 #define _XFS_CKSUM_H 1
470
471-#define XFS_CRC_SEED (~(__uint32_t)0)
472+#define XFS_CRC_SEED (~(uint32_t)0)
473
474 /*
475 * Calculate the intermediate checksum for a buffer that has the CRC field
476@@ -9,11 +9,11 @@
477 * cksum_offset parameter. We do not modify the buffer during verification,
478 * hence we have to split the CRC calculation across the cksum_offset.
479 */
480-static inline __uint32_t
481+static inline uint32_t
482 xfs_start_cksum_safe(char *buffer, size_t length, unsigned long cksum_offset)
483 {
484- __uint32_t zero = 0;
485- __uint32_t crc;
486+ uint32_t zero = 0;
487+ uint32_t crc;
488
489 /* Calculate CRC up to the checksum. */
490 crc = crc32c(XFS_CRC_SEED, buffer, cksum_offset);
491@@ -30,7 +30,7 @@ xfs_start_cksum_safe(char *buffer, size_t length, unsigned long cksum_offset)
492 * Fast CRC method where the buffer is modified. Callers must have exclusive
493 * access to the buffer while the calculation takes place.
494 */
495-static inline __uint32_t
496+static inline uint32_t
497 xfs_start_cksum_update(char *buffer, size_t length, unsigned long cksum_offset)
498 {
499 /* zero the CRC field */
500@@ -48,7 +48,7 @@ xfs_start_cksum_update(char *buffer, size_t length, unsigned long cksum_offset)
501 * so that it is consistent on disk.
502 */
503 static inline __le32
504-xfs_end_cksum(__uint32_t crc)
505+xfs_end_cksum(uint32_t crc)
506 {
507 return ~cpu_to_le32(crc);
508 }
509@@ -62,7 +62,7 @@ xfs_end_cksum(__uint32_t crc)
510 static inline void
511 xfs_update_cksum(char *buffer, size_t length, unsigned long cksum_offset)
512 {
513- __uint32_t crc = xfs_start_cksum_update(buffer, length, cksum_offset);
514+ uint32_t crc = xfs_start_cksum_update(buffer, length, cksum_offset);
515
516 *(__le32 *)(buffer + cksum_offset) = xfs_end_cksum(crc);
517 }
518@@ -73,7 +73,7 @@ xfs_update_cksum(char *buffer, size_t length, unsigned long cksum_offset)
519 static inline int
520 xfs_verify_cksum(char *buffer, size_t length, unsigned long cksum_offset)
521 {
522- __uint32_t crc = xfs_start_cksum_safe(buffer, length, cksum_offset);
523+ uint32_t crc = xfs_start_cksum_safe(buffer, length, cksum_offset);
524
525 return *(__le32 *)(buffer + cksum_offset) == xfs_end_cksum(crc);
526 }
527diff --git a/libxfs/xfs_da_btree.c b/libxfs/xfs_da_btree.c
528index bc12f58f..08447be8 100644
529--- a/libxfs/xfs_da_btree.c
530+++ b/libxfs/xfs_da_btree.c
531@@ -1947,7 +1947,7 @@ xfs_da3_path_shift(
532 * This is implemented with some source-level loop unrolling.
533 */
534 xfs_dahash_t
535-xfs_da_hashname(const __uint8_t *name, int namelen)
536+xfs_da_hashname(const uint8_t *name, int namelen)
537 {
538 xfs_dahash_t hash;
539
540diff --git a/libxfs/xfs_da_btree.h b/libxfs/xfs_da_btree.h
541index 4e29cb6a..ae6de174 100644
542--- a/libxfs/xfs_da_btree.h
543+++ b/libxfs/xfs_da_btree.h
544@@ -60,10 +60,10 @@ enum xfs_dacmp {
545 */
546 typedef struct xfs_da_args {
547 struct xfs_da_geometry *geo; /* da block geometry */
548- const __uint8_t *name; /* string (maybe not NULL terminated) */
549+ const uint8_t *name; /* string (maybe not NULL terminated) */
550 int namelen; /* length of string (maybe no NULL) */
551- __uint8_t filetype; /* filetype of inode for directories */
552- __uint8_t *value; /* set of bytes (maybe contain NULLs) */
553+ uint8_t filetype; /* filetype of inode for directories */
554+ uint8_t *value; /* set of bytes (maybe contain NULLs) */
555 int valuelen; /* length of value */
556 int flags; /* argument flags (eg: ATTR_NOCREATE) */
557 xfs_dahash_t hashval; /* hash value of name */
558@@ -207,7 +207,7 @@ int xfs_da_reada_buf(struct xfs_inode *dp, xfs_dablk_t bno,
559 int xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,
560 struct xfs_buf *dead_buf);
561
562-uint xfs_da_hashname(const __uint8_t *name_string, int name_length);
563+uint xfs_da_hashname(const uint8_t *name_string, int name_length);
564 enum xfs_dacmp xfs_da_compname(struct xfs_da_args *args,
565 const unsigned char *name, int len);
566
567diff --git a/libxfs/xfs_da_format.c b/libxfs/xfs_da_format.c
568index 2b732b3c..f30004f6 100644
569--- a/libxfs/xfs_da_format.c
570+++ b/libxfs/xfs_da_format.c
571@@ -49,7 +49,7 @@ xfs_dir3_sf_entsize(
572 struct xfs_dir2_sf_hdr *hdr,
573 int len)
574 {
575- return xfs_dir2_sf_entsize(hdr, len) + sizeof(__uint8_t);
576+ return xfs_dir2_sf_entsize(hdr, len) + sizeof(uint8_t);
577 }
578
579 static struct xfs_dir2_sf_entry *
580@@ -77,7 +77,7 @@ xfs_dir3_sf_nextentry(
581 * not necessary. For non-filetype enable directories, the type is always
582 * unknown and we never store the value.
583 */
584-static __uint8_t
585+static uint8_t
586 xfs_dir2_sfe_get_ftype(
587 struct xfs_dir2_sf_entry *sfep)
588 {
589@@ -87,16 +87,16 @@ xfs_dir2_sfe_get_ftype(
590 static void
591 xfs_dir2_sfe_put_ftype(
592 struct xfs_dir2_sf_entry *sfep,
593- __uint8_t ftype)
594+ uint8_t ftype)
595 {
596 ASSERT(ftype < XFS_DIR3_FT_MAX);
597 }
598
599-static __uint8_t
600+static uint8_t
601 xfs_dir3_sfe_get_ftype(
602 struct xfs_dir2_sf_entry *sfep)
603 {
604- __uint8_t ftype;
605+ uint8_t ftype;
606
607 ftype = sfep->name[sfep->namelen];
608 if (ftype >= XFS_DIR3_FT_MAX)
609@@ -107,7 +107,7 @@ xfs_dir3_sfe_get_ftype(
610 static void
611 xfs_dir3_sfe_put_ftype(
612 struct xfs_dir2_sf_entry *sfep,
613- __uint8_t ftype)
614+ uint8_t ftype)
615 {
616 ASSERT(ftype < XFS_DIR3_FT_MAX);
617
618@@ -124,7 +124,7 @@ xfs_dir3_sfe_put_ftype(
619 static xfs_ino_t
620 xfs_dir2_sf_get_ino(
621 struct xfs_dir2_sf_hdr *hdr,
622- __uint8_t *from)
623+ uint8_t *from)
624 {
625 if (hdr->i8count)
626 return get_unaligned_be64(from) & 0x00ffffffffffffffULL;
627@@ -135,7 +135,7 @@ xfs_dir2_sf_get_ino(
628 static void
629 xfs_dir2_sf_put_ino(
630 struct xfs_dir2_sf_hdr *hdr,
631- __uint8_t *to,
632+ uint8_t *to,
633 xfs_ino_t ino)
634 {
635 ASSERT((ino & 0xff00000000000000ULL) == 0);
636@@ -225,7 +225,7 @@ xfs_dir3_sfe_put_ino(
637
638 #define XFS_DIR3_DATA_ENTSIZE(n) \
639 round_up((offsetof(struct xfs_dir2_data_entry, name[0]) + (n) + \
640- sizeof(xfs_dir2_data_off_t) + sizeof(__uint8_t)), \
641+ sizeof(xfs_dir2_data_off_t) + sizeof(uint8_t)), \
642 XFS_DIR2_DATA_ALIGN)
643
644 static int
645@@ -242,7 +242,7 @@ xfs_dir3_data_entsize(
646 return XFS_DIR3_DATA_ENTSIZE(n);
647 }
648
649-static __uint8_t
650+static uint8_t
651 xfs_dir2_data_get_ftype(
652 struct xfs_dir2_data_entry *dep)
653 {
654@@ -252,16 +252,16 @@ xfs_dir2_data_get_ftype(
655 static void
656 xfs_dir2_data_put_ftype(
657 struct xfs_dir2_data_entry *dep,
658- __uint8_t ftype)
659+ uint8_t ftype)
660 {
661 ASSERT(ftype < XFS_DIR3_FT_MAX);
662 }
663
664-static __uint8_t
665+static uint8_t
666 xfs_dir3_data_get_ftype(
667 struct xfs_dir2_data_entry *dep)
668 {
669- __uint8_t ftype = dep->name[dep->namelen];
670+ uint8_t ftype = dep->name[dep->namelen];
671
672 if (ftype >= XFS_DIR3_FT_MAX)
673 return XFS_DIR3_FT_UNKNOWN;
674@@ -271,7 +271,7 @@ xfs_dir3_data_get_ftype(
675 static void
676 xfs_dir3_data_put_ftype(
677 struct xfs_dir2_data_entry *dep,
678- __uint8_t type)
679+ uint8_t type)
680 {
681 ASSERT(type < XFS_DIR3_FT_MAX);
682 ASSERT(dep->namelen != 0);
683diff --git a/libxfs/xfs_da_format.h b/libxfs/xfs_da_format.h
684index 9a492a9e..3771edcb 100644
685--- a/libxfs/xfs_da_format.h
686+++ b/libxfs/xfs_da_format.h
687@@ -111,11 +111,11 @@ struct xfs_da3_intnode {
688 * appropriate.
689 */
690 struct xfs_da3_icnode_hdr {
691- __uint32_t forw;
692- __uint32_t back;
693- __uint16_t magic;
694- __uint16_t count;
695- __uint16_t level;
696+ uint32_t forw;
697+ uint32_t back;
698+ uint16_t magic;
699+ uint16_t count;
700+ uint16_t level;
701 };
702
703 /*
704@@ -187,14 +187,14 @@ struct xfs_da3_icnode_hdr {
705 /*
706 * Byte offset in data block and shortform entry.
707 */
708-typedef __uint16_t xfs_dir2_data_off_t;
709+typedef uint16_t xfs_dir2_data_off_t;
710 #define NULLDATAOFF 0xffffU
711 typedef uint xfs_dir2_data_aoff_t; /* argument form */
712
713 /*
714 * Offset in data space of a data entry.
715 */
716-typedef __uint32_t xfs_dir2_dataptr_t;
717+typedef uint32_t xfs_dir2_dataptr_t;
718 #define XFS_DIR2_MAX_DATAPTR ((xfs_dir2_dataptr_t)0xffffffff)
719 #define XFS_DIR2_NULL_DATAPTR ((xfs_dir2_dataptr_t)0)
720
721@@ -206,7 +206,7 @@ typedef xfs_off_t xfs_dir2_off_t;
722 /*
723 * Directory block number (logical dirblk in file)
724 */
725-typedef __uint32_t xfs_dir2_db_t;
726+typedef uint32_t xfs_dir2_db_t;
727
728 #define XFS_INO32_SIZE 4
729 #define XFS_INO64_SIZE 8
730@@ -226,9 +226,9 @@ typedef __uint32_t xfs_dir2_db_t;
731 * over them.
732 */
733 typedef struct xfs_dir2_sf_hdr {
734- __uint8_t count; /* count of entries */
735- __uint8_t i8count; /* count of 8-byte inode #s */
736- __uint8_t parent[8]; /* parent dir inode number */
737+ uint8_t count; /* count of entries */
738+ uint8_t i8count; /* count of 8-byte inode #s */
739+ uint8_t parent[8]; /* parent dir inode number */
740 } __packed xfs_dir2_sf_hdr_t;
741
742 typedef struct xfs_dir2_sf_entry {
743@@ -447,11 +447,11 @@ struct xfs_dir3_leaf_hdr {
744 };
745
746 struct xfs_dir3_icleaf_hdr {
747- __uint32_t forw;
748- __uint32_t back;
749- __uint16_t magic;
750- __uint16_t count;
751- __uint16_t stale;
752+ uint32_t forw;
753+ uint32_t back;
754+ uint16_t magic;
755+ uint16_t count;
756+ uint16_t stale;
757 };
758
759 /*
760@@ -538,10 +538,10 @@ struct xfs_dir3_free {
761 * xfs_dir3_free_hdr_from_disk/xfs_dir3_free_hdr_to_disk.
762 */
763 struct xfs_dir3_icfree_hdr {
764- __uint32_t magic;
765- __uint32_t firstdb;
766- __uint32_t nvalid;
767- __uint32_t nused;
768+ uint32_t magic;
769+ uint32_t firstdb;
770+ uint32_t nvalid;
771+ uint32_t nused;
772
773 };
774
775@@ -632,10 +632,10 @@ typedef struct xfs_attr_shortform {
776 __u8 padding;
777 } hdr;
778 struct xfs_attr_sf_entry {
779- __uint8_t namelen; /* actual length of name (no NULL) */
780- __uint8_t valuelen; /* actual length of value (no NULL) */
781- __uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */
782- __uint8_t nameval[1]; /* name & value bytes concatenated */
783+ uint8_t namelen; /* actual length of name (no NULL) */
784+ uint8_t valuelen; /* actual length of value (no NULL) */
785+ uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */
786+ uint8_t nameval[1]; /* name & value bytes concatenated */
787 } list[1]; /* variable sized array */
788 } xfs_attr_shortform_t;
789
790@@ -725,22 +725,22 @@ struct xfs_attr3_leafblock {
791 * incore, neutral version of the attribute leaf header
792 */
793 struct xfs_attr3_icleaf_hdr {
794- __uint32_t forw;
795- __uint32_t back;
796- __uint16_t magic;
797- __uint16_t count;
798- __uint16_t usedbytes;
799+ uint32_t forw;
800+ uint32_t back;
801+ uint16_t magic;
802+ uint16_t count;
803+ uint16_t usedbytes;
804 /*
805 * firstused is 32-bit here instead of 16-bit like the on-disk variant
806 * to support maximum fsb size of 64k without overflow issues throughout
807 * the attr code. Instead, the overflow condition is handled on
808 * conversion to/from disk.
809 */
810- __uint32_t firstused;
811+ uint32_t firstused;
812 __u8 holes;
813 struct {
814- __uint16_t base;
815- __uint16_t size;
816+ uint16_t base;
817+ uint16_t size;
818 } freemap[XFS_ATTR_LEAF_MAPSIZE];
819 };
820
821diff --git a/libxfs/xfs_dir2.h b/libxfs/xfs_dir2.h
822index d6e6d9d1..21c8f8bf 100644
823--- a/libxfs/xfs_dir2.h
824+++ b/libxfs/xfs_dir2.h
825@@ -47,9 +47,9 @@ struct xfs_dir_ops {
826 struct xfs_dir2_sf_entry *
827 (*sf_nextentry)(struct xfs_dir2_sf_hdr *hdr,
828 struct xfs_dir2_sf_entry *sfep);
829- __uint8_t (*sf_get_ftype)(struct xfs_dir2_sf_entry *sfep);
830+ uint8_t (*sf_get_ftype)(struct xfs_dir2_sf_entry *sfep);
831 void (*sf_put_ftype)(struct xfs_dir2_sf_entry *sfep,
832- __uint8_t ftype);
833+ uint8_t ftype);
834 xfs_ino_t (*sf_get_ino)(struct xfs_dir2_sf_hdr *hdr,
835 struct xfs_dir2_sf_entry *sfep);
836 void (*sf_put_ino)(struct xfs_dir2_sf_hdr *hdr,
837@@ -60,9 +60,9 @@ struct xfs_dir_ops {
838 xfs_ino_t ino);
839
840 int (*data_entsize)(int len);
841- __uint8_t (*data_get_ftype)(struct xfs_dir2_data_entry *dep);
842+ uint8_t (*data_get_ftype)(struct xfs_dir2_data_entry *dep);
843 void (*data_put_ftype)(struct xfs_dir2_data_entry *dep,
844- __uint8_t ftype);
845+ uint8_t ftype);
846 __be16 * (*data_entry_tag_p)(struct xfs_dir2_data_entry *dep);
847 struct xfs_dir2_data_free *
848 (*data_bestfree_p)(struct xfs_dir2_data_hdr *hdr);
849diff --git a/libxfs/xfs_dir2_leaf.c b/libxfs/xfs_dir2_leaf.c
850index f80d91fc..40a35b84 100644
851--- a/libxfs/xfs_dir2_leaf.c
852+++ b/libxfs/xfs_dir2_leaf.c
853@@ -142,7 +142,7 @@ xfs_dir3_leaf_check_int(
854 static bool
855 xfs_dir3_leaf_verify(
856 struct xfs_buf *bp,
857- __uint16_t magic)
858+ uint16_t magic)
859 {
860 struct xfs_mount *mp = bp->b_target->bt_mount;
861 struct xfs_dir2_leaf *leaf = bp->b_addr;
862@@ -151,7 +151,7 @@ xfs_dir3_leaf_verify(
863
864 if (xfs_sb_version_hascrc(&mp->m_sb)) {
865 struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
866- __uint16_t magic3;
867+ uint16_t magic3;
868
869 magic3 = (magic == XFS_DIR2_LEAF1_MAGIC) ? XFS_DIR3_LEAF1_MAGIC
870 : XFS_DIR3_LEAFN_MAGIC;
871@@ -175,7 +175,7 @@ xfs_dir3_leaf_verify(
872 static void
873 __read_verify(
874 struct xfs_buf *bp,
875- __uint16_t magic)
876+ uint16_t magic)
877 {
878 struct xfs_mount *mp = bp->b_target->bt_mount;
879
880@@ -192,7 +192,7 @@ __read_verify(
881 static void
882 __write_verify(
883 struct xfs_buf *bp,
884- __uint16_t magic)
885+ uint16_t magic)
886 {
887 struct xfs_mount *mp = bp->b_target->bt_mount;
888 struct xfs_buf_log_item *bip = bp->b_fspriv;
889@@ -296,7 +296,7 @@ xfs_dir3_leaf_init(
890 struct xfs_trans *tp,
891 struct xfs_buf *bp,
892 xfs_ino_t owner,
893- __uint16_t type)
894+ uint16_t type)
895 {
896 struct xfs_dir2_leaf *leaf = bp->b_addr;
897
898@@ -340,7 +340,7 @@ xfs_dir3_leaf_get_buf(
899 xfs_da_args_t *args,
900 xfs_dir2_db_t bno,
901 struct xfs_buf **bpp,
902- __uint16_t magic)
903+ uint16_t magic)
904 {
905 struct xfs_inode *dp = args->dp;
906 struct xfs_trans *tp = args->trans;
907diff --git a/libxfs/xfs_dir2_priv.h b/libxfs/xfs_dir2_priv.h
908index 39f8604f..011df4da 100644
909--- a/libxfs/xfs_dir2_priv.h
910+++ b/libxfs/xfs_dir2_priv.h
911@@ -69,7 +69,7 @@ extern void xfs_dir3_leaf_compact_x1(struct xfs_dir3_icleaf_hdr *leafhdr,
912 struct xfs_dir2_leaf_entry *ents, int *indexp,
913 int *lowstalep, int *highstalep, int *lowlogp, int *highlogp);
914 extern int xfs_dir3_leaf_get_buf(struct xfs_da_args *args, xfs_dir2_db_t bno,
915- struct xfs_buf **bpp, __uint16_t magic);
916+ struct xfs_buf **bpp, uint16_t magic);
917 extern void xfs_dir3_leaf_log_ents(struct xfs_da_args *args,
918 struct xfs_buf *bp, int first, int last);
919 extern void xfs_dir3_leaf_log_header(struct xfs_da_args *args,
920diff --git a/libxfs/xfs_dir2_sf.c b/libxfs/xfs_dir2_sf.c
921index 195f816d..0c453988 100644
922--- a/libxfs/xfs_dir2_sf.c
923+++ b/libxfs/xfs_dir2_sf.c
924@@ -125,7 +125,7 @@ xfs_dir2_block_sfsize(
925 * Calculate the new size, see if we should give up yet.
926 */
927 size = xfs_dir2_sf_hdr_size(i8count) + /* header */
928- count * 3 * sizeof(__u8) + /* namelen + offset */
929+ count * 3 * sizeof(u8) + /* namelen + offset */
930 namelen + /* name */
931 (i8count ? /* inumber */
932 count * XFS_INO64_SIZE :
933@@ -645,7 +645,7 @@ xfs_dir2_sf_verify(
934 int offset;
935 int size;
936 int error;
937- __uint8_t filetype;
938+ uint8_t filetype;
939
940 ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_LOCAL);
941 /*
942diff --git a/libxfs/xfs_format.h b/libxfs/xfs_format.h
943index 4c3ed1fd..a53f035f 100644
944--- a/libxfs/xfs_format.h
945+++ b/libxfs/xfs_format.h
946@@ -103,8 +103,8 @@ struct xfs_ifork;
947 * Must be padded to 64 bit alignment.
948 */
949 typedef struct xfs_sb {
950- __uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */
951- __uint32_t sb_blocksize; /* logical block size, bytes */
952+ uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */
953+ uint32_t sb_blocksize; /* logical block size, bytes */
954 xfs_rfsblock_t sb_dblocks; /* number of data blocks */
955 xfs_rfsblock_t sb_rblocks; /* number of realtime blocks */
956 xfs_rtblock_t sb_rextents; /* number of realtime extents */
957@@ -118,45 +118,45 @@ typedef struct xfs_sb {
958 xfs_agnumber_t sb_agcount; /* number of allocation groups */
959 xfs_extlen_t sb_rbmblocks; /* number of rt bitmap blocks */
960 xfs_extlen_t sb_logblocks; /* number of log blocks */
961- __uint16_t sb_versionnum; /* header version == XFS_SB_VERSION */
962- __uint16_t sb_sectsize; /* volume sector size, bytes */
963- __uint16_t sb_inodesize; /* inode size, bytes */
964- __uint16_t sb_inopblock; /* inodes per block */
965+ uint16_t sb_versionnum; /* header version == XFS_SB_VERSION */
966+ uint16_t sb_sectsize; /* volume sector size, bytes */
967+ uint16_t sb_inodesize; /* inode size, bytes */
968+ uint16_t sb_inopblock; /* inodes per block */
969 char sb_fname[12]; /* file system name */
970- __uint8_t sb_blocklog; /* log2 of sb_blocksize */
971- __uint8_t sb_sectlog; /* log2 of sb_sectsize */
972- __uint8_t sb_inodelog; /* log2 of sb_inodesize */
973- __uint8_t sb_inopblog; /* log2 of sb_inopblock */
974- __uint8_t sb_agblklog; /* log2 of sb_agblocks (rounded up) */
975- __uint8_t sb_rextslog; /* log2 of sb_rextents */
976- __uint8_t sb_inprogress; /* mkfs is in progress, don't mount */
977- __uint8_t sb_imax_pct; /* max % of fs for inode space */
978+ uint8_t sb_blocklog; /* log2 of sb_blocksize */
979+ uint8_t sb_sectlog; /* log2 of sb_sectsize */
980+ uint8_t sb_inodelog; /* log2 of sb_inodesize */
981+ uint8_t sb_inopblog; /* log2 of sb_inopblock */
982+ uint8_t sb_agblklog; /* log2 of sb_agblocks (rounded up) */
983+ uint8_t sb_rextslog; /* log2 of sb_rextents */
984+ uint8_t sb_inprogress; /* mkfs is in progress, don't mount */
985+ uint8_t sb_imax_pct; /* max % of fs for inode space */
986 /* statistics */
987 /*
988 * These fields must remain contiguous. If you really
989 * want to change their layout, make sure you fix the
990 * code in xfs_trans_apply_sb_deltas().
991 */
992- __uint64_t sb_icount; /* allocated inodes */
993- __uint64_t sb_ifree; /* free inodes */
994- __uint64_t sb_fdblocks; /* free data blocks */
995- __uint64_t sb_frextents; /* free realtime extents */
996+ uint64_t sb_icount; /* allocated inodes */
997+ uint64_t sb_ifree; /* free inodes */
998+ uint64_t sb_fdblocks; /* free data blocks */
999+ uint64_t sb_frextents; /* free realtime extents */
1000 /*
1001 * End contiguous fields.
1002 */
1003 xfs_ino_t sb_uquotino; /* user quota inode */
1004 xfs_ino_t sb_gquotino; /* group quota inode */
1005- __uint16_t sb_qflags; /* quota flags */
1006- __uint8_t sb_flags; /* misc. flags */
1007- __uint8_t sb_shared_vn; /* shared version number */
1008+ uint16_t sb_qflags; /* quota flags */
1009+ uint8_t sb_flags; /* misc. flags */
1010+ uint8_t sb_shared_vn; /* shared version number */
1011 xfs_extlen_t sb_inoalignmt; /* inode chunk alignment, fsblocks */
1012- __uint32_t sb_unit; /* stripe or raid unit */
1013- __uint32_t sb_width; /* stripe or raid width */
1014- __uint8_t sb_dirblklog; /* log2 of dir block size (fsbs) */
1015- __uint8_t sb_logsectlog; /* log2 of the log sector size */
1016- __uint16_t sb_logsectsize; /* sector size for the log, bytes */
1017- __uint32_t sb_logsunit; /* stripe unit size for the log */
1018- __uint32_t sb_features2; /* additional feature bits */
1019+ uint32_t sb_unit; /* stripe or raid unit */
1020+ uint32_t sb_width; /* stripe or raid width */
1021+ uint8_t sb_dirblklog; /* log2 of dir block size (fsbs) */
1022+ uint8_t sb_logsectlog; /* log2 of the log sector size */
1023+ uint16_t sb_logsectsize; /* sector size for the log, bytes */
1024+ uint32_t sb_logsunit; /* stripe unit size for the log */
1025+ uint32_t sb_features2; /* additional feature bits */
1026
1027 /*
1028 * bad features2 field as a result of failing to pad the sb structure to
1029@@ -167,17 +167,17 @@ typedef struct xfs_sb {
1030 * the value in sb_features2 when formatting the incore superblock to
1031 * the disk buffer.
1032 */
1033- __uint32_t sb_bad_features2;
1034+ uint32_t sb_bad_features2;
1035
1036 /* version 5 superblock fields start here */
1037
1038 /* feature masks */
1039- __uint32_t sb_features_compat;
1040- __uint32_t sb_features_ro_compat;
1041- __uint32_t sb_features_incompat;
1042- __uint32_t sb_features_log_incompat;
1043+ uint32_t sb_features_compat;
1044+ uint32_t sb_features_ro_compat;
1045+ uint32_t sb_features_incompat;
1046+ uint32_t sb_features_log_incompat;
1047
1048- __uint32_t sb_crc; /* superblock crc */
1049+ uint32_t sb_crc; /* superblock crc */
1050 xfs_extlen_t sb_spino_align; /* sparse inode chunk alignment */
1051
1052 xfs_ino_t sb_pquotino; /* project quota inode */
1053@@ -449,7 +449,7 @@ static inline void xfs_sb_version_addprojid32bit(struct xfs_sb *sbp)
1054 static inline bool
1055 xfs_sb_has_compat_feature(
1056 struct xfs_sb *sbp,
1057- __uint32_t feature)
1058+ uint32_t feature)
1059 {
1060 return (sbp->sb_features_compat & feature) != 0;
1061 }
1062@@ -465,7 +465,7 @@ xfs_sb_has_compat_feature(
1063 static inline bool
1064 xfs_sb_has_ro_compat_feature(
1065 struct xfs_sb *sbp,
1066- __uint32_t feature)
1067+ uint32_t feature)
1068 {
1069 return (sbp->sb_features_ro_compat & feature) != 0;
1070 }
1071@@ -482,7 +482,7 @@ xfs_sb_has_ro_compat_feature(
1072 static inline bool
1073 xfs_sb_has_incompat_feature(
1074 struct xfs_sb *sbp,
1075- __uint32_t feature)
1076+ uint32_t feature)
1077 {
1078 return (sbp->sb_features_incompat & feature) != 0;
1079 }
1080@@ -492,7 +492,7 @@ xfs_sb_has_incompat_feature(
1081 static inline bool
1082 xfs_sb_has_incompat_log_feature(
1083 struct xfs_sb *sbp,
1084- __uint32_t feature)
1085+ uint32_t feature)
1086 {
1087 return (sbp->sb_features_log_incompat & feature) != 0;
1088 }
1089@@ -594,8 +594,8 @@ xfs_is_quota_inode(struct xfs_sb *sbp, xfs_ino_t ino)
1090 */
1091 #define XFS_FSB_TO_B(mp,fsbno) ((xfs_fsize_t)(fsbno) << (mp)->m_sb.sb_blocklog)
1092 #define XFS_B_TO_FSB(mp,b) \
1093- ((((__uint64_t)(b)) + (mp)->m_blockmask) >> (mp)->m_sb.sb_blocklog)
1094-#define XFS_B_TO_FSBT(mp,b) (((__uint64_t)(b)) >> (mp)->m_sb.sb_blocklog)
1095+ ((((uint64_t)(b)) + (mp)->m_blockmask) >> (mp)->m_sb.sb_blocklog)
1096+#define XFS_B_TO_FSBT(mp,b) (((uint64_t)(b)) >> (mp)->m_sb.sb_blocklog)
1097 #define XFS_B_FSB_OFFSET(mp,b) ((b) & (mp)->m_blockmask)
1098
1099 /*
1100@@ -1072,7 +1072,7 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
1101 * next agno_log bits - ag number
1102 * high agno_log-agblklog-inopblog bits - 0
1103 */
1104-#define XFS_INO_MASK(k) (__uint32_t)((1ULL << (k)) - 1)
1105+#define XFS_INO_MASK(k) (uint32_t)((1ULL << (k)) - 1)
1106 #define XFS_INO_OFFSET_BITS(mp) (mp)->m_sb.sb_inopblog
1107 #define XFS_INO_AGBNO_BITS(mp) (mp)->m_sb.sb_agblklog
1108 #define XFS_INO_AGINO_BITS(mp) (mp)->m_agino_log
1109@@ -1269,16 +1269,16 @@ typedef __be32 xfs_alloc_ptr_t;
1110 #define XFS_FIBT_MAGIC 0x46494254 /* 'FIBT' */
1111 #define XFS_FIBT_CRC_MAGIC 0x46494233 /* 'FIB3' */
1112
1113-typedef __uint64_t xfs_inofree_t;
1114+typedef uint64_t xfs_inofree_t;
1115 #define XFS_INODES_PER_CHUNK (NBBY * sizeof(xfs_inofree_t))
1116 #define XFS_INODES_PER_CHUNK_LOG (XFS_NBBYLOG + 3)
1117 #define XFS_INOBT_ALL_FREE ((xfs_inofree_t)-1)
1118 #define XFS_INOBT_MASK(i) ((xfs_inofree_t)1 << (i))
1119
1120 #define XFS_INOBT_HOLEMASK_FULL 0 /* holemask for full chunk */
1121-#define XFS_INOBT_HOLEMASK_BITS (NBBY * sizeof(__uint16_t))
1122+#define XFS_INOBT_HOLEMASK_BITS (NBBY * sizeof(uint16_t))
1123 #define XFS_INODES_PER_HOLEMASK_BIT \
1124- (XFS_INODES_PER_CHUNK / (NBBY * sizeof(__uint16_t)))
1125+ (XFS_INODES_PER_CHUNK / (NBBY * sizeof(uint16_t)))
1126
1127 static inline xfs_inofree_t xfs_inobt_maskn(int i, int n)
1128 {
1129@@ -1312,9 +1312,9 @@ typedef struct xfs_inobt_rec {
1130
1131 typedef struct xfs_inobt_rec_incore {
1132 xfs_agino_t ir_startino; /* starting inode number */
1133- __uint16_t ir_holemask; /* hole mask for sparse chunks */
1134- __uint8_t ir_count; /* total inode count */
1135- __uint8_t ir_freecount; /* count of free inodes (set bits) */
1136+ uint16_t ir_holemask; /* hole mask for sparse chunks */
1137+ uint8_t ir_count; /* total inode count */
1138+ uint8_t ir_freecount; /* count of free inodes (set bits) */
1139 xfs_inofree_t ir_free; /* free inode mask */
1140 } xfs_inobt_rec_incore_t;
1141
1142@@ -1397,15 +1397,15 @@ struct xfs_rmap_rec {
1143 * rm_offset:54-60 aren't used and should be zero
1144 * rm_offset:0-53 is the block offset within the inode
1145 */
1146-#define XFS_RMAP_OFF_ATTR_FORK ((__uint64_t)1ULL << 63)
1147-#define XFS_RMAP_OFF_BMBT_BLOCK ((__uint64_t)1ULL << 62)
1148-#define XFS_RMAP_OFF_UNWRITTEN ((__uint64_t)1ULL << 61)
1149+#define XFS_RMAP_OFF_ATTR_FORK ((uint64_t)1ULL << 63)
1150+#define XFS_RMAP_OFF_BMBT_BLOCK ((uint64_t)1ULL << 62)
1151+#define XFS_RMAP_OFF_UNWRITTEN ((uint64_t)1ULL << 61)
1152
1153-#define XFS_RMAP_LEN_MAX ((__uint32_t)~0U)
1154+#define XFS_RMAP_LEN_MAX ((uint32_t)~0U)
1155 #define XFS_RMAP_OFF_FLAGS (XFS_RMAP_OFF_ATTR_FORK | \
1156 XFS_RMAP_OFF_BMBT_BLOCK | \
1157 XFS_RMAP_OFF_UNWRITTEN)
1158-#define XFS_RMAP_OFF_MASK ((__uint64_t)0x3FFFFFFFFFFFFFULL)
1159+#define XFS_RMAP_OFF_MASK ((uint64_t)0x3FFFFFFFFFFFFFULL)
1160
1161 #define XFS_RMAP_OFF(off) ((off) & XFS_RMAP_OFF_MASK)
1162
1163@@ -1431,8 +1431,8 @@ struct xfs_rmap_rec {
1164 struct xfs_rmap_irec {
1165 xfs_agblock_t rm_startblock; /* extent start block */
1166 xfs_extlen_t rm_blockcount; /* extent length */
1167- __uint64_t rm_owner; /* extent owner */
1168- __uint64_t rm_offset; /* offset within the owner */
1169+ uint64_t rm_owner; /* extent owner */
1170+ uint64_t rm_offset; /* offset within the owner */
1171 unsigned int rm_flags; /* state flags */
1172 };
1173
1174@@ -1544,11 +1544,11 @@ typedef struct xfs_bmbt_rec {
1175 __be64 l0, l1;
1176 } xfs_bmbt_rec_t;
1177
1178-typedef __uint64_t xfs_bmbt_rec_base_t; /* use this for casts */
1179+typedef uint64_t xfs_bmbt_rec_base_t; /* use this for casts */
1180 typedef xfs_bmbt_rec_t xfs_bmdr_rec_t;
1181
1182 typedef struct xfs_bmbt_rec_host {
1183- __uint64_t l0, l1;
1184+ uint64_t l0, l1;
1185 } xfs_bmbt_rec_host_t;
1186
1187 /*
1188diff --git a/libxfs/xfs_fs.h b/libxfs/xfs_fs.h
1189index 99f7f881..8a0c0eec 100644
1190--- a/libxfs/xfs_fs.h
1191+++ b/libxfs/xfs_fs.h
1192@@ -323,10 +323,10 @@ typedef struct xfs_bstat {
1193 * and using two 16bit values to hold new 32bit projid was choosen
1194 * to retain compatibility with "old" filesystems).
1195 */
1196-static inline __uint32_t
1197+static inline uint32_t
1198 bstat_get_projid(struct xfs_bstat *bs)
1199 {
1200- return (__uint32_t)bs->bs_projid_hi << 16 | bs->bs_projid_lo;
1201+ return (uint32_t)bs->bs_projid_hi << 16 | bs->bs_projid_lo;
1202 }
1203
1204 /*
1205@@ -472,10 +472,10 @@ typedef struct xfs_handle {
1206 */
1207 typedef struct xfs_swapext
1208 {
1209- __int64_t sx_version; /* version */
1210+ int64_t sx_version; /* version */
1211 #define XFS_SX_VERSION 0
1212- __int64_t sx_fdtarget; /* fd of target file */
1213- __int64_t sx_fdtmp; /* fd of tmp file */
1214+ int64_t sx_fdtarget; /* fd of target file */
1215+ int64_t sx_fdtmp; /* fd of tmp file */
1216 xfs_off_t sx_offset; /* offset into file */
1217 xfs_off_t sx_length; /* leng from offset */
1218 char sx_pad[16]; /* pad space, unused */
1219@@ -562,7 +562,7 @@ typedef struct xfs_swapext
1220 #define XFS_IOC_ATTRLIST_BY_HANDLE _IOW ('X', 122, struct xfs_fsop_attrlist_handlereq)
1221 #define XFS_IOC_ATTRMULTI_BY_HANDLE _IOW ('X', 123, struct xfs_fsop_attrmulti_handlereq)
1222 #define XFS_IOC_FSGEOMETRY _IOR ('X', 124, struct xfs_fsop_geom)
1223-#define XFS_IOC_GOINGDOWN _IOR ('X', 125, __uint32_t)
1224+#define XFS_IOC_GOINGDOWN _IOR ('X', 125, uint32_t)
1225 /* XFS_IOC_GETFSUUID ---------- deprecated 140 */
1226
1227 /* reflink ioctls; these MUST match the btrfs ioctl definitions */
1228diff --git a/libxfs/xfs_ialloc.c b/libxfs/xfs_ialloc.c
1229index 55cc4507..8d245184 100644
1230--- a/libxfs/xfs_ialloc.c
1231+++ b/libxfs/xfs_ialloc.c
1232@@ -134,9 +134,9 @@ xfs_inobt_get_rec(
1233 STATIC int
1234 xfs_inobt_insert_rec(
1235 struct xfs_btree_cur *cur,
1236- __uint16_t holemask,
1237- __uint8_t count,
1238- __int32_t freecount,
1239+ uint16_t holemask,
1240+ uint8_t count,
1241+ int32_t freecount,
1242 xfs_inofree_t free,
1243 int *stat)
1244 {
1245diff --git a/libxfs/xfs_ialloc_btree.c b/libxfs/xfs_ialloc_btree.c
1246index 7b4be766..5b281054 100644
1247--- a/libxfs/xfs_ialloc_btree.c
1248+++ b/libxfs/xfs_ialloc_btree.c
1249@@ -218,12 +218,12 @@ xfs_finobt_init_ptr_from_cur(
1250 ptr->s = agi->agi_free_root;
1251 }
1252
1253-STATIC __int64_t
1254+STATIC int64_t
1255 xfs_inobt_key_diff(
1256 struct xfs_btree_cur *cur,
1257 union xfs_btree_key *key)
1258 {
1259- return (__int64_t)be32_to_cpu(key->inobt.ir_startino) -
1260+ return (int64_t)be32_to_cpu(key->inobt.ir_startino) -
1261 cur->bc_rec.i.ir_startino;
1262 }
1263
1264diff --git a/libxfs/xfs_inode_buf.c b/libxfs/xfs_inode_buf.c
1265index 2972701d..fcc6fb8e 100644
1266--- a/libxfs/xfs_inode_buf.c
1267+++ b/libxfs/xfs_inode_buf.c
1268@@ -442,7 +442,7 @@ xfs_dinode_calc_crc(
1269 struct xfs_mount *mp,
1270 struct xfs_dinode *dip)
1271 {
1272- __uint32_t crc;
1273+ uint32_t crc;
1274
1275 if (dip->di_version < 3)
1276 return;
1277diff --git a/libxfs/xfs_inode_buf.h b/libxfs/xfs_inode_buf.h
1278index 6848a0af..0827d7de 100644
1279--- a/libxfs/xfs_inode_buf.h
1280+++ b/libxfs/xfs_inode_buf.h
1281@@ -28,26 +28,26 @@ struct xfs_dinode;
1282 * format specific structures at the appropriate time.
1283 */
1284 struct xfs_icdinode {
1285- __int8_t di_version; /* inode version */
1286- __int8_t di_format; /* format of di_c data */
1287- __uint16_t di_flushiter; /* incremented on flush */
1288- __uint32_t di_uid; /* owner's user id */
1289- __uint32_t di_gid; /* owner's group id */
1290- __uint16_t di_projid_lo; /* lower part of owner's project id */
1291- __uint16_t di_projid_hi; /* higher part of owner's project id */
1292+ int8_t di_version; /* inode version */
1293+ int8_t di_format; /* format of di_c data */
1294+ uint16_t di_flushiter; /* incremented on flush */
1295+ uint32_t di_uid; /* owner's user id */
1296+ uint32_t di_gid; /* owner's group id */
1297+ uint16_t di_projid_lo; /* lower part of owner's project id */
1298+ uint16_t di_projid_hi; /* higher part of owner's project id */
1299 xfs_fsize_t di_size; /* number of bytes in file */
1300 xfs_rfsblock_t di_nblocks; /* # of direct & btree blocks used */
1301 xfs_extlen_t di_extsize; /* basic/minimum extent size for file */
1302 xfs_extnum_t di_nextents; /* number of extents in data fork */
1303 xfs_aextnum_t di_anextents; /* number of extents in attribute fork*/
1304- __uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */
1305- __int8_t di_aformat; /* format of attr fork's data */
1306- __uint32_t di_dmevmask; /* DMIG event mask */
1307- __uint16_t di_dmstate; /* DMIG state info */
1308- __uint16_t di_flags; /* random flags, XFS_DIFLAG_... */
1309+ uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */
1310+ int8_t di_aformat; /* format of attr fork's data */
1311+ uint32_t di_dmevmask; /* DMIG event mask */
1312+ uint16_t di_dmstate; /* DMIG state info */
1313+ uint16_t di_flags; /* random flags, XFS_DIFLAG_... */
1314
1315- __uint64_t di_flags2; /* more random flags */
1316- __uint32_t di_cowextsize; /* basic cow extent size for file */
1317+ uint64_t di_flags2; /* more random flags */
1318+ uint32_t di_cowextsize; /* basic cow extent size for file */
1319
1320 xfs_ictimestamp_t di_crtime; /* time created */
1321 };
1322diff --git a/libxfs/xfs_log_format.h b/libxfs/xfs_log_format.h
1323index 7ae571f8..8372e9bc 100644
1324--- a/libxfs/xfs_log_format.h
1325+++ b/libxfs/xfs_log_format.h
1326@@ -31,7 +31,7 @@ struct xfs_trans_res;
1327 * through all the log items definitions and everything they encode into the
1328 * log.
1329 */
1330-typedef __uint32_t xlog_tid_t;
1331+typedef uint32_t xlog_tid_t;
1332
1333 #define XLOG_MIN_ICLOGS 2
1334 #define XLOG_MAX_ICLOGS 8
1335@@ -211,7 +211,7 @@ typedef struct xfs_log_iovec {
1336 typedef struct xfs_trans_header {
1337 uint th_magic; /* magic number */
1338 uint th_type; /* transaction type */
1339- __int32_t th_tid; /* transaction id (unused) */
1340+ int32_t th_tid; /* transaction id (unused) */
1341 uint th_num_items; /* num items logged by trans */
1342 } xfs_trans_header_t;
1343
1344@@ -265,52 +265,52 @@ typedef struct xfs_trans_header {
1345 * must be added on to the end.
1346 */
1347 typedef struct xfs_inode_log_format {
1348- __uint16_t ilf_type; /* inode log item type */
1349- __uint16_t ilf_size; /* size of this item */
1350- __uint32_t ilf_fields; /* flags for fields logged */
1351- __uint16_t ilf_asize; /* size of attr d/ext/root */
1352- __uint16_t ilf_dsize; /* size of data/ext/root */
1353- __uint64_t ilf_ino; /* inode number */
1354+ uint16_t ilf_type; /* inode log item type */
1355+ uint16_t ilf_size; /* size of this item */
1356+ uint32_t ilf_fields; /* flags for fields logged */
1357+ uint16_t ilf_asize; /* size of attr d/ext/root */
1358+ uint16_t ilf_dsize; /* size of data/ext/root */
1359+ uint64_t ilf_ino; /* inode number */
1360 union {
1361- __uint32_t ilfu_rdev; /* rdev value for dev inode*/
1362+ uint32_t ilfu_rdev; /* rdev value for dev inode*/
1363 uuid_t ilfu_uuid; /* mount point value */
1364 } ilf_u;
1365- __int64_t ilf_blkno; /* blkno of inode buffer */
1366- __int32_t ilf_len; /* len of inode buffer */
1367- __int32_t ilf_boffset; /* off of inode in buffer */
1368+ int64_t ilf_blkno; /* blkno of inode buffer */
1369+ int32_t ilf_len; /* len of inode buffer */
1370+ int32_t ilf_boffset; /* off of inode in buffer */
1371 } xfs_inode_log_format_t;
1372
1373 typedef struct xfs_inode_log_format_32 {
1374- __uint16_t ilf_type; /* inode log item type */
1375- __uint16_t ilf_size; /* size of this item */
1376- __uint32_t ilf_fields; /* flags for fields logged */
1377- __uint16_t ilf_asize; /* size of attr d/ext/root */
1378- __uint16_t ilf_dsize; /* size of data/ext/root */
1379- __uint64_t ilf_ino; /* inode number */
1380+ uint16_t ilf_type; /* inode log item type */
1381+ uint16_t ilf_size; /* size of this item */
1382+ uint32_t ilf_fields; /* flags for fields logged */
1383+ uint16_t ilf_asize; /* size of attr d/ext/root */
1384+ uint16_t ilf_dsize; /* size of data/ext/root */
1385+ uint64_t ilf_ino; /* inode number */
1386 union {
1387- __uint32_t ilfu_rdev; /* rdev value for dev inode*/
1388+ uint32_t ilfu_rdev; /* rdev value for dev inode*/
1389 uuid_t ilfu_uuid; /* mount point value */
1390 } ilf_u;
1391- __int64_t ilf_blkno; /* blkno of inode buffer */
1392- __int32_t ilf_len; /* len of inode buffer */
1393- __int32_t ilf_boffset; /* off of inode in buffer */
1394+ int64_t ilf_blkno; /* blkno of inode buffer */
1395+ int32_t ilf_len; /* len of inode buffer */
1396+ int32_t ilf_boffset; /* off of inode in buffer */
1397 } __attribute__((packed)) xfs_inode_log_format_32_t;
1398
1399 typedef struct xfs_inode_log_format_64 {
1400- __uint16_t ilf_type; /* inode log item type */
1401- __uint16_t ilf_size; /* size of this item */
1402- __uint32_t ilf_fields; /* flags for fields logged */
1403- __uint16_t ilf_asize; /* size of attr d/ext/root */
1404- __uint16_t ilf_dsize; /* size of data/ext/root */
1405- __uint32_t ilf_pad; /* pad for 64 bit boundary */
1406- __uint64_t ilf_ino; /* inode number */
1407+ uint16_t ilf_type; /* inode log item type */
1408+ uint16_t ilf_size; /* size of this item */
1409+ uint32_t ilf_fields; /* flags for fields logged */
1410+ uint16_t ilf_asize; /* size of attr d/ext/root */
1411+ uint16_t ilf_dsize; /* size of data/ext/root */
1412+ uint32_t ilf_pad; /* pad for 64 bit boundary */
1413+ uint64_t ilf_ino; /* inode number */
1414 union {
1415- __uint32_t ilfu_rdev; /* rdev value for dev inode*/
1416+ uint32_t ilfu_rdev; /* rdev value for dev inode*/
1417 uuid_t ilfu_uuid; /* mount point value */
1418 } ilf_u;
1419- __int64_t ilf_blkno; /* blkno of inode buffer */
1420- __int32_t ilf_len; /* len of inode buffer */
1421- __int32_t ilf_boffset; /* off of inode in buffer */
1422+ int64_t ilf_blkno; /* blkno of inode buffer */
1423+ int32_t ilf_len; /* len of inode buffer */
1424+ int32_t ilf_boffset; /* off of inode in buffer */
1425 } xfs_inode_log_format_64_t;
1426
1427
1428@@ -379,8 +379,8 @@ static inline int xfs_ilog_fdata(int w)
1429 * information.
1430 */
1431 typedef struct xfs_ictimestamp {
1432- __int32_t t_sec; /* timestamp seconds */
1433- __int32_t t_nsec; /* timestamp nanoseconds */
1434+ int32_t t_sec; /* timestamp seconds */
1435+ int32_t t_nsec; /* timestamp nanoseconds */
1436 } xfs_ictimestamp_t;
1437
1438 /*
1439@@ -388,18 +388,18 @@ typedef struct xfs_ictimestamp {
1440 * kept identical to struct xfs_dinode except for the endianness annotations.
1441 */
1442 struct xfs_log_dinode {
1443- __uint16_t di_magic; /* inode magic # = XFS_DINODE_MAGIC */
1444- __uint16_t di_mode; /* mode and type of file */
1445- __int8_t di_version; /* inode version */
1446- __int8_t di_format; /* format of di_c data */
1447- __uint8_t di_pad3[2]; /* unused in v2/3 inodes */
1448- __uint32_t di_uid; /* owner's user id */
1449- __uint32_t di_gid; /* owner's group id */
1450- __uint32_t di_nlink; /* number of links to file */
1451- __uint16_t di_projid_lo; /* lower part of owner's project id */
1452- __uint16_t di_projid_hi; /* higher part of owner's project id */
1453- __uint8_t di_pad[6]; /* unused, zeroed space */
1454- __uint16_t di_flushiter; /* incremented on flush */
1455+ uint16_t di_magic; /* inode magic # = XFS_DINODE_MAGIC */
1456+ uint16_t di_mode; /* mode and type of file */
1457+ int8_t di_version; /* inode version */
1458+ int8_t di_format; /* format of di_c data */
1459+ uint8_t di_pad3[2]; /* unused in v2/3 inodes */
1460+ uint32_t di_uid; /* owner's user id */
1461+ uint32_t di_gid; /* owner's group id */
1462+ uint32_t di_nlink; /* number of links to file */
1463+ uint16_t di_projid_lo; /* lower part of owner's project id */
1464+ uint16_t di_projid_hi; /* higher part of owner's project id */
1465+ uint8_t di_pad[6]; /* unused, zeroed space */
1466+ uint16_t di_flushiter; /* incremented on flush */
1467 xfs_ictimestamp_t di_atime; /* time last accessed */
1468 xfs_ictimestamp_t di_mtime; /* time last modified */
1469 xfs_ictimestamp_t di_ctime; /* time created/inode modified */
1470@@ -408,23 +408,23 @@ struct xfs_log_dinode {
1471 xfs_extlen_t di_extsize; /* basic/minimum extent size for file */
1472 xfs_extnum_t di_nextents; /* number of extents in data fork */
1473 xfs_aextnum_t di_anextents; /* number of extents in attribute fork*/
1474- __uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */
1475- __int8_t di_aformat; /* format of attr fork's data */
1476- __uint32_t di_dmevmask; /* DMIG event mask */
1477- __uint16_t di_dmstate; /* DMIG state info */
1478- __uint16_t di_flags; /* random flags, XFS_DIFLAG_... */
1479- __uint32_t di_gen; /* generation number */
1480+ uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */
1481+ int8_t di_aformat; /* format of attr fork's data */
1482+ uint32_t di_dmevmask; /* DMIG event mask */
1483+ uint16_t di_dmstate; /* DMIG state info */
1484+ uint16_t di_flags; /* random flags, XFS_DIFLAG_... */
1485+ uint32_t di_gen; /* generation number */
1486
1487 /* di_next_unlinked is the only non-core field in the old dinode */
1488 xfs_agino_t di_next_unlinked;/* agi unlinked list ptr */
1489
1490 /* start of the extended dinode, writable fields */
1491- __uint32_t di_crc; /* CRC of the inode */
1492- __uint64_t di_changecount; /* number of attribute changes */
1493+ uint32_t di_crc; /* CRC of the inode */
1494+ uint64_t di_changecount; /* number of attribute changes */
1495 xfs_lsn_t di_lsn; /* flush sequence */
1496- __uint64_t di_flags2; /* more random flags */
1497- __uint32_t di_cowextsize; /* basic cow extent size for file */
1498- __uint8_t di_pad2[12]; /* more padding for future expansion */
1499+ uint64_t di_flags2; /* more random flags */
1500+ uint32_t di_cowextsize; /* basic cow extent size for file */
1501+ uint8_t di_pad2[12]; /* more padding for future expansion */
1502
1503 /* fields only written to during inode creation */
1504 xfs_ictimestamp_t di_crtime; /* time created */
1505@@ -483,7 +483,7 @@ typedef struct xfs_buf_log_format {
1506 unsigned short blf_size; /* size of this item */
1507 unsigned short blf_flags; /* misc state */
1508 unsigned short blf_len; /* number of blocks in this buf */
1509- __int64_t blf_blkno; /* starting blkno of this buf */
1510+ int64_t blf_blkno; /* starting blkno of this buf */
1511 unsigned int blf_map_size; /* used size of data bitmap in words */
1512 unsigned int blf_data_map[XFS_BLF_DATAMAP_SIZE]; /* dirty bitmap */
1513 } xfs_buf_log_format_t;
1514@@ -533,7 +533,7 @@ xfs_blft_to_flags(struct xfs_buf_log_format *blf, enum xfs_blft type)
1515 blf->blf_flags |= ((type << XFS_BLFT_SHIFT) & XFS_BLFT_MASK);
1516 }
1517
1518-static inline __uint16_t
1519+static inline uint16_t
1520 xfs_blft_from_flags(struct xfs_buf_log_format *blf)
1521 {
1522 return (blf->blf_flags & XFS_BLFT_MASK) >> XFS_BLFT_SHIFT;
1523@@ -554,14 +554,14 @@ typedef struct xfs_extent {
1524 * conversion routine.
1525 */
1526 typedef struct xfs_extent_32 {
1527- __uint64_t ext_start;
1528- __uint32_t ext_len;
1529+ uint64_t ext_start;
1530+ uint32_t ext_len;
1531 } __attribute__((packed)) xfs_extent_32_t;
1532
1533 typedef struct xfs_extent_64 {
1534- __uint64_t ext_start;
1535- __uint32_t ext_len;
1536- __uint32_t ext_pad;
1537+ uint64_t ext_start;
1538+ uint32_t ext_len;
1539+ uint32_t ext_pad;
1540 } xfs_extent_64_t;
1541
1542 /*
1543@@ -570,26 +570,26 @@ typedef struct xfs_extent_64 {
1544 * size is given by efi_nextents.
1545 */
1546 typedef struct xfs_efi_log_format {
1547- __uint16_t efi_type; /* efi log item type */
1548- __uint16_t efi_size; /* size of this item */
1549- __uint32_t efi_nextents; /* # extents to free */
1550- __uint64_t efi_id; /* efi identifier */
1551+ uint16_t efi_type; /* efi log item type */
1552+ uint16_t efi_size; /* size of this item */
1553+ uint32_t efi_nextents; /* # extents to free */
1554+ uint64_t efi_id; /* efi identifier */
1555 xfs_extent_t efi_extents[1]; /* array of extents to free */
1556 } xfs_efi_log_format_t;
1557
1558 typedef struct xfs_efi_log_format_32 {
1559- __uint16_t efi_type; /* efi log item type */
1560- __uint16_t efi_size; /* size of this item */
1561- __uint32_t efi_nextents; /* # extents to free */
1562- __uint64_t efi_id; /* efi identifier */
1563+ uint16_t efi_type; /* efi log item type */
1564+ uint16_t efi_size; /* size of this item */
1565+ uint32_t efi_nextents; /* # extents to free */
1566+ uint64_t efi_id; /* efi identifier */
1567 xfs_extent_32_t efi_extents[1]; /* array of extents to free */
1568 } __attribute__((packed)) xfs_efi_log_format_32_t;
1569
1570 typedef struct xfs_efi_log_format_64 {
1571- __uint16_t efi_type; /* efi log item type */
1572- __uint16_t efi_size; /* size of this item */
1573- __uint32_t efi_nextents; /* # extents to free */
1574- __uint64_t efi_id; /* efi identifier */
1575+ uint16_t efi_type; /* efi log item type */
1576+ uint16_t efi_size; /* size of this item */
1577+ uint32_t efi_nextents; /* # extents to free */
1578+ uint64_t efi_id; /* efi identifier */
1579 xfs_extent_64_t efi_extents[1]; /* array of extents to free */
1580 } xfs_efi_log_format_64_t;
1581
1582@@ -599,26 +599,26 @@ typedef struct xfs_efi_log_format_64 {
1583 * size is given by efd_nextents;
1584 */
1585 typedef struct xfs_efd_log_format {
1586- __uint16_t efd_type; /* efd log item type */
1587- __uint16_t efd_size; /* size of this item */
1588- __uint32_t efd_nextents; /* # of extents freed */
1589- __uint64_t efd_efi_id; /* id of corresponding efi */
1590+ uint16_t efd_type; /* efd log item type */
1591+ uint16_t efd_size; /* size of this item */
1592+ uint32_t efd_nextents; /* # of extents freed */
1593+ uint64_t efd_efi_id; /* id of corresponding efi */
1594 xfs_extent_t efd_extents[1]; /* array of extents freed */
1595 } xfs_efd_log_format_t;
1596
1597 typedef struct xfs_efd_log_format_32 {
1598- __uint16_t efd_type; /* efd log item type */
1599- __uint16_t efd_size; /* size of this item */
1600- __uint32_t efd_nextents; /* # of extents freed */
1601- __uint64_t efd_efi_id; /* id of corresponding efi */
1602+ uint16_t efd_type; /* efd log item type */
1603+ uint16_t efd_size; /* size of this item */
1604+ uint32_t efd_nextents; /* # of extents freed */
1605+ uint64_t efd_efi_id; /* id of corresponding efi */
1606 xfs_extent_32_t efd_extents[1]; /* array of extents freed */
1607 } __attribute__((packed)) xfs_efd_log_format_32_t;
1608
1609 typedef struct xfs_efd_log_format_64 {
1610- __uint16_t efd_type; /* efd log item type */
1611- __uint16_t efd_size; /* size of this item */
1612- __uint32_t efd_nextents; /* # of extents freed */
1613- __uint64_t efd_efi_id; /* id of corresponding efi */
1614+ uint16_t efd_type; /* efd log item type */
1615+ uint16_t efd_size; /* size of this item */
1616+ uint32_t efd_nextents; /* # of extents freed */
1617+ uint64_t efd_efi_id; /* id of corresponding efi */
1618 xfs_extent_64_t efd_extents[1]; /* array of extents freed */
1619 } xfs_efd_log_format_64_t;
1620
1621@@ -626,11 +626,11 @@ typedef struct xfs_efd_log_format_64 {
1622 * RUI/RUD (reverse mapping) log format definitions
1623 */
1624 struct xfs_map_extent {
1625- __uint64_t me_owner;
1626- __uint64_t me_startblock;
1627- __uint64_t me_startoff;
1628- __uint32_t me_len;
1629- __uint32_t me_flags;
1630+ uint64_t me_owner;
1631+ uint64_t me_startblock;
1632+ uint64_t me_startoff;
1633+ uint32_t me_len;
1634+ uint32_t me_flags;
1635 };
1636
1637 /* rmap me_flags: upper bits are flags, lower byte is type code */
1638@@ -659,10 +659,10 @@ struct xfs_map_extent {
1639 * size is given by rui_nextents.
1640 */
1641 struct xfs_rui_log_format {
1642- __uint16_t rui_type; /* rui log item type */
1643- __uint16_t rui_size; /* size of this item */
1644- __uint32_t rui_nextents; /* # extents to free */
1645- __uint64_t rui_id; /* rui identifier */
1646+ uint16_t rui_type; /* rui log item type */
1647+ uint16_t rui_size; /* size of this item */
1648+ uint32_t rui_nextents; /* # extents to free */
1649+ uint64_t rui_id; /* rui identifier */
1650 struct xfs_map_extent rui_extents[]; /* array of extents to rmap */
1651 };
1652
1653@@ -680,19 +680,19 @@ xfs_rui_log_format_sizeof(
1654 * size is given by rud_nextents;
1655 */
1656 struct xfs_rud_log_format {
1657- __uint16_t rud_type; /* rud log item type */
1658- __uint16_t rud_size; /* size of this item */
1659- __uint32_t __pad;
1660- __uint64_t rud_rui_id; /* id of corresponding rui */
1661+ uint16_t rud_type; /* rud log item type */
1662+ uint16_t rud_size; /* size of this item */
1663+ uint32_t __pad;
1664+ uint64_t rud_rui_id; /* id of corresponding rui */
1665 };
1666
1667 /*
1668 * CUI/CUD (refcount update) log format definitions
1669 */
1670 struct xfs_phys_extent {
1671- __uint64_t pe_startblock;
1672- __uint32_t pe_len;
1673- __uint32_t pe_flags;
1674+ uint64_t pe_startblock;
1675+ uint32_t pe_len;
1676+ uint32_t pe_flags;
1677 };
1678
1679 /* refcount pe_flags: upper bits are flags, lower byte is type code */
1680@@ -707,10 +707,10 @@ struct xfs_phys_extent {
1681 * size is given by cui_nextents.
1682 */
1683 struct xfs_cui_log_format {
1684- __uint16_t cui_type; /* cui log item type */
1685- __uint16_t cui_size; /* size of this item */
1686- __uint32_t cui_nextents; /* # extents to free */
1687- __uint64_t cui_id; /* cui identifier */
1688+ uint16_t cui_type; /* cui log item type */
1689+ uint16_t cui_size; /* size of this item */
1690+ uint32_t cui_nextents; /* # extents to free */
1691+ uint64_t cui_id; /* cui identifier */
1692 struct xfs_phys_extent cui_extents[]; /* array of extents */
1693 };
1694
1695@@ -728,10 +728,10 @@ xfs_cui_log_format_sizeof(
1696 * size is given by cud_nextents;
1697 */
1698 struct xfs_cud_log_format {
1699- __uint16_t cud_type; /* cud log item type */
1700- __uint16_t cud_size; /* size of this item */
1701- __uint32_t __pad;
1702- __uint64_t cud_cui_id; /* id of corresponding cui */
1703+ uint16_t cud_type; /* cud log item type */
1704+ uint16_t cud_size; /* size of this item */
1705+ uint32_t __pad;
1706+ uint64_t cud_cui_id; /* id of corresponding cui */
1707 };
1708
1709 /*
1710@@ -755,10 +755,10 @@ struct xfs_cud_log_format {
1711 * size is given by bui_nextents.
1712 */
1713 struct xfs_bui_log_format {
1714- __uint16_t bui_type; /* bui log item type */
1715- __uint16_t bui_size; /* size of this item */
1716- __uint32_t bui_nextents; /* # extents to free */
1717- __uint64_t bui_id; /* bui identifier */
1718+ uint16_t bui_type; /* bui log item type */
1719+ uint16_t bui_size; /* size of this item */
1720+ uint32_t bui_nextents; /* # extents to free */
1721+ uint64_t bui_id; /* bui identifier */
1722 struct xfs_map_extent bui_extents[]; /* array of extents to bmap */
1723 };
1724
1725@@ -776,10 +776,10 @@ xfs_bui_log_format_sizeof(
1726 * size is given by bud_nextents;
1727 */
1728 struct xfs_bud_log_format {
1729- __uint16_t bud_type; /* bud log item type */
1730- __uint16_t bud_size; /* size of this item */
1731- __uint32_t __pad;
1732- __uint64_t bud_bui_id; /* id of corresponding bui */
1733+ uint16_t bud_type; /* bud log item type */
1734+ uint16_t bud_size; /* size of this item */
1735+ uint32_t __pad;
1736+ uint64_t bud_bui_id; /* id of corresponding bui */
1737 };
1738
1739 /*
1740@@ -789,12 +789,12 @@ struct xfs_bud_log_format {
1741 * 32 bits : log_recovery code assumes that.
1742 */
1743 typedef struct xfs_dq_logformat {
1744- __uint16_t qlf_type; /* dquot log item type */
1745- __uint16_t qlf_size; /* size of this item */
1746+ uint16_t qlf_type; /* dquot log item type */
1747+ uint16_t qlf_size; /* size of this item */
1748 xfs_dqid_t qlf_id; /* usr/grp/proj id : 32 bits */
1749- __int64_t qlf_blkno; /* blkno of dquot buffer */
1750- __int32_t qlf_len; /* len of dquot buffer */
1751- __uint32_t qlf_boffset; /* off of dquot in buffer */
1752+ int64_t qlf_blkno; /* blkno of dquot buffer */
1753+ int32_t qlf_len; /* len of dquot buffer */
1754+ uint32_t qlf_boffset; /* off of dquot in buffer */
1755 } xfs_dq_logformat_t;
1756
1757 /*
1758@@ -853,8 +853,8 @@ typedef struct xfs_qoff_logformat {
1759 * decoding can be done correctly.
1760 */
1761 struct xfs_icreate_log {
1762- __uint16_t icl_type; /* type of log format structure */
1763- __uint16_t icl_size; /* size of log format structure */
1764+ uint16_t icl_type; /* type of log format structure */
1765+ uint16_t icl_size; /* size of log format structure */
1766 __be32 icl_ag; /* ag being allocated in */
1767 __be32 icl_agbno; /* start block of inode range */
1768 __be32 icl_count; /* number of inodes to initialise */
1769diff --git a/libxfs/xfs_quota_defs.h b/libxfs/xfs_quota_defs.h
1770index 8eed5127..d69c7722 100644
1771--- a/libxfs/xfs_quota_defs.h
1772+++ b/libxfs/xfs_quota_defs.h
1773@@ -27,8 +27,8 @@
1774 * they may need 64-bit accounting. Hence, 64-bit quota-counters,
1775 * and quota-limits. This is a waste in the common case, but hey ...
1776 */
1777-typedef __uint64_t xfs_qcnt_t;
1778-typedef __uint16_t xfs_qwarncnt_t;
1779+typedef uint64_t xfs_qcnt_t;
1780+typedef uint16_t xfs_qwarncnt_t;
1781
1782 /*
1783 * flags for q_flags field in the dquot.
1784diff --git a/libxfs/xfs_refcount_btree.c b/libxfs/xfs_refcount_btree.c
1785index 2814f94f..bd1a8f2d 100644
1786--- a/libxfs/xfs_refcount_btree.c
1787+++ b/libxfs/xfs_refcount_btree.c
1788@@ -201,7 +201,7 @@ xfs_refcountbt_init_ptr_from_cur(
1789 ptr->s = agf->agf_refcount_root;
1790 }
1791
1792-STATIC __int64_t
1793+STATIC int64_t
1794 xfs_refcountbt_key_diff(
1795 struct xfs_btree_cur *cur,
1796 union xfs_btree_key *key)
1797@@ -209,16 +209,16 @@ xfs_refcountbt_key_diff(
1798 struct xfs_refcount_irec *rec = &cur->bc_rec.rc;
1799 struct xfs_refcount_key *kp = &key->refc;
1800
1801- return (__int64_t)be32_to_cpu(kp->rc_startblock) - rec->rc_startblock;
1802+ return (int64_t)be32_to_cpu(kp->rc_startblock) - rec->rc_startblock;
1803 }
1804
1805-STATIC __int64_t
1806+STATIC int64_t
1807 xfs_refcountbt_diff_two_keys(
1808 struct xfs_btree_cur *cur,
1809 union xfs_btree_key *k1,
1810 union xfs_btree_key *k2)
1811 {
1812- return (__int64_t)be32_to_cpu(k1->refc.rc_startblock) -
1813+ return (int64_t)be32_to_cpu(k1->refc.rc_startblock) -
1814 be32_to_cpu(k2->refc.rc_startblock);
1815 }
1816
1817diff --git a/libxfs/xfs_rmap.c b/libxfs/xfs_rmap.c
1818index f78771d1..0d6b5d41 100644
1819--- a/libxfs/xfs_rmap.c
1820+++ b/libxfs/xfs_rmap.c
1821@@ -2059,7 +2059,7 @@ int
1822 xfs_rmap_finish_one(
1823 struct xfs_trans *tp,
1824 enum xfs_rmap_intent_type type,
1825- __uint64_t owner,
1826+ uint64_t owner,
1827 int whichfork,
1828 xfs_fileoff_t startoff,
1829 xfs_fsblock_t startblock,
1830@@ -2180,7 +2180,7 @@ __xfs_rmap_add(
1831 struct xfs_mount *mp,
1832 struct xfs_defer_ops *dfops,
1833 enum xfs_rmap_intent_type type,
1834- __uint64_t owner,
1835+ uint64_t owner,
1836 int whichfork,
1837 struct xfs_bmbt_irec *bmap)
1838 {
1839@@ -2264,7 +2264,7 @@ xfs_rmap_alloc_extent(
1840 xfs_agnumber_t agno,
1841 xfs_agblock_t bno,
1842 xfs_extlen_t len,
1843- __uint64_t owner)
1844+ uint64_t owner)
1845 {
1846 struct xfs_bmbt_irec bmap;
1847
1848@@ -2288,7 +2288,7 @@ xfs_rmap_free_extent(
1849 xfs_agnumber_t agno,
1850 xfs_agblock_t bno,
1851 xfs_extlen_t len,
1852- __uint64_t owner)
1853+ uint64_t owner)
1854 {
1855 struct xfs_bmbt_irec bmap;
1856
1857diff --git a/libxfs/xfs_rmap.h b/libxfs/xfs_rmap.h
1858index 98f908fe..265116d0 100644
1859--- a/libxfs/xfs_rmap.h
1860+++ b/libxfs/xfs_rmap.h
1861@@ -179,7 +179,7 @@ enum xfs_rmap_intent_type {
1862 struct xfs_rmap_intent {
1863 struct list_head ri_list;
1864 enum xfs_rmap_intent_type ri_type;
1865- __uint64_t ri_owner;
1866+ uint64_t ri_owner;
1867 int ri_whichfork;
1868 struct xfs_bmbt_irec ri_bmap;
1869 };
1870@@ -196,15 +196,15 @@ int xfs_rmap_convert_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
1871 struct xfs_bmbt_irec *imap);
1872 int xfs_rmap_alloc_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
1873 xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len,
1874- __uint64_t owner);
1875+ uint64_t owner);
1876 int xfs_rmap_free_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
1877 xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len,
1878- __uint64_t owner);
1879+ uint64_t owner);
1880
1881 void xfs_rmap_finish_one_cleanup(struct xfs_trans *tp,
1882 struct xfs_btree_cur *rcur, int error);
1883 int xfs_rmap_finish_one(struct xfs_trans *tp, enum xfs_rmap_intent_type type,
1884- __uint64_t owner, int whichfork, xfs_fileoff_t startoff,
1885+ uint64_t owner, int whichfork, xfs_fileoff_t startoff,
1886 xfs_fsblock_t startblock, xfs_filblks_t blockcount,
1887 xfs_exntst_t state, struct xfs_btree_cur **pcur);
1888
1889diff --git a/libxfs/xfs_rmap_btree.c b/libxfs/xfs_rmap_btree.c
1890index a186c872..45ac436f 100644
1891--- a/libxfs/xfs_rmap_btree.c
1892+++ b/libxfs/xfs_rmap_btree.c
1893@@ -197,7 +197,7 @@ xfs_rmapbt_init_high_key_from_rec(
1894 union xfs_btree_key *key,
1895 union xfs_btree_rec *rec)
1896 {
1897- __uint64_t off;
1898+ uint64_t off;
1899 int adj;
1900
1901 adj = be32_to_cpu(rec->rmap.rm_blockcount) - 1;
1902@@ -239,7 +239,7 @@ xfs_rmapbt_init_ptr_from_cur(
1903 ptr->s = agf->agf_roots[cur->bc_btnum];
1904 }
1905
1906-STATIC __int64_t
1907+STATIC int64_t
1908 xfs_rmapbt_key_diff(
1909 struct xfs_btree_cur *cur,
1910 union xfs_btree_key *key)
1911@@ -247,9 +247,9 @@ xfs_rmapbt_key_diff(
1912 struct xfs_rmap_irec *rec = &cur->bc_rec.r;
1913 struct xfs_rmap_key *kp = &key->rmap;
1914 __u64 x, y;
1915- __int64_t d;
1916+ int64_t d;
1917
1918- d = (__int64_t)be32_to_cpu(kp->rm_startblock) - rec->rm_startblock;
1919+ d = (int64_t)be32_to_cpu(kp->rm_startblock) - rec->rm_startblock;
1920 if (d)
1921 return d;
1922
1923@@ -269,7 +269,7 @@ xfs_rmapbt_key_diff(
1924 return 0;
1925 }
1926
1927-STATIC __int64_t
1928+STATIC int64_t
1929 xfs_rmapbt_diff_two_keys(
1930 struct xfs_btree_cur *cur,
1931 union xfs_btree_key *k1,
1932@@ -277,10 +277,10 @@ xfs_rmapbt_diff_two_keys(
1933 {
1934 struct xfs_rmap_key *kp1 = &k1->rmap;
1935 struct xfs_rmap_key *kp2 = &k2->rmap;
1936- __int64_t d;
1937+ int64_t d;
1938 __u64 x, y;
1939
1940- d = (__int64_t)be32_to_cpu(kp1->rm_startblock) -
1941+ d = (int64_t)be32_to_cpu(kp1->rm_startblock) -
1942 be32_to_cpu(kp2->rm_startblock);
1943 if (d)
1944 return d;
1945@@ -382,10 +382,10 @@ xfs_rmapbt_keys_inorder(
1946 union xfs_btree_key *k1,
1947 union xfs_btree_key *k2)
1948 {
1949- __uint32_t x;
1950- __uint32_t y;
1951- __uint64_t a;
1952- __uint64_t b;
1953+ uint32_t x;
1954+ uint32_t y;
1955+ uint64_t a;
1956+ uint64_t b;
1957
1958 x = be32_to_cpu(k1->rmap.rm_startblock);
1959 y = be32_to_cpu(k2->rmap.rm_startblock);
1960@@ -412,10 +412,10 @@ xfs_rmapbt_recs_inorder(
1961 union xfs_btree_rec *r1,
1962 union xfs_btree_rec *r2)
1963 {
1964- __uint32_t x;
1965- __uint32_t y;
1966- __uint64_t a;
1967- __uint64_t b;
1968+ uint32_t x;
1969+ uint32_t y;
1970+ uint64_t a;
1971+ uint64_t b;
1972
1973 x = be32_to_cpu(r1->rmap.rm_startblock);
1974 y = be32_to_cpu(r2->rmap.rm_startblock);
1975diff --git a/libxfs/xfs_rtbitmap.c b/libxfs/xfs_rtbitmap.c
1976index dbd2f881..8f8a99d6 100644
1977--- a/libxfs/xfs_rtbitmap.c
1978+++ b/libxfs/xfs_rtbitmap.c
1979@@ -1006,7 +1006,7 @@ xfs_rtfree_extent(
1980 mp->m_sb.sb_rextents) {
1981 if (!(mp->m_rbmip->i_d.di_flags & XFS_DIFLAG_NEWRTBM))
1982 mp->m_rbmip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM;
1983- *(__uint64_t *)&VFS_I(mp->m_rbmip)->i_atime = 0;
1984+ *(uint64_t *)&VFS_I(mp->m_rbmip)->i_atime = 0;
1985 xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE);
1986 }
1987 return 0;
1988diff --git a/libxfs/xfs_sb.c b/libxfs/xfs_sb.c
1989index 93a18190..51f69704 100644
1990--- a/libxfs/xfs_sb.c
1991+++ b/libxfs/xfs_sb.c
1992@@ -430,7 +430,7 @@ xfs_sb_quota_to_disk(
1993 struct xfs_dsb *to,
1994 struct xfs_sb *from)
1995 {
1996- __uint16_t qflags = from->sb_qflags;
1997+ uint16_t qflags = from->sb_qflags;
1998
1999 to->sb_uquotino = cpu_to_be64(from->sb_uquotino);
2000 if (xfs_sb_version_has_pquotino(from)) {
2001@@ -738,7 +738,7 @@ xfs_sb_mount_common(
2002 mp->m_refc_mnr[1] = mp->m_refc_mxr[1] / 2;
2003
2004 mp->m_bsize = XFS_FSB_TO_BB(mp, 1);
2005- mp->m_ialloc_inos = (int)MAX((__uint16_t)XFS_INODES_PER_CHUNK,
2006+ mp->m_ialloc_inos = (int)MAX((uint16_t)XFS_INODES_PER_CHUNK,
2007 sbp->sb_inopblock);
2008 mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog;
2009
2010diff --git a/libxfs/xfs_types.h b/libxfs/xfs_types.h
2011index 717909f2..0220159b 100644
2012--- a/libxfs/xfs_types.h
2013+++ b/libxfs/xfs_types.h
2014@@ -18,34 +18,34 @@
2015 #ifndef __XFS_TYPES_H__
2016 #define __XFS_TYPES_H__
2017
2018-typedef __uint32_t prid_t; /* project ID */
2019+typedef uint32_t prid_t; /* project ID */
2020
2021-typedef __uint32_t xfs_agblock_t; /* blockno in alloc. group */
2022-typedef __uint32_t xfs_agino_t; /* inode # within allocation grp */
2023-typedef __uint32_t xfs_extlen_t; /* extent length in blocks */
2024-typedef __uint32_t xfs_agnumber_t; /* allocation group number */
2025-typedef __int32_t xfs_extnum_t; /* # of extents in a file */
2026-typedef __int16_t xfs_aextnum_t; /* # extents in an attribute fork */
2027-typedef __int64_t xfs_fsize_t; /* bytes in a file */
2028-typedef __uint64_t xfs_ufsize_t; /* unsigned bytes in a file */
2029+typedef uint32_t xfs_agblock_t; /* blockno in alloc. group */
2030+typedef uint32_t xfs_agino_t; /* inode # within allocation grp */
2031+typedef uint32_t xfs_extlen_t; /* extent length in blocks */
2032+typedef uint32_t xfs_agnumber_t; /* allocation group number */
2033+typedef int32_t xfs_extnum_t; /* # of extents in a file */
2034+typedef int16_t xfs_aextnum_t; /* # extents in an attribute fork */
2035+typedef int64_t xfs_fsize_t; /* bytes in a file */
2036+typedef uint64_t xfs_ufsize_t; /* unsigned bytes in a file */
2037
2038-typedef __int32_t xfs_suminfo_t; /* type of bitmap summary info */
2039-typedef __int32_t xfs_rtword_t; /* word type for bitmap manipulations */
2040+typedef int32_t xfs_suminfo_t; /* type of bitmap summary info */
2041+typedef int32_t xfs_rtword_t; /* word type for bitmap manipulations */
2042
2043-typedef __int64_t xfs_lsn_t; /* log sequence number */
2044-typedef __int32_t xfs_tid_t; /* transaction identifier */
2045+typedef int64_t xfs_lsn_t; /* log sequence number */
2046+typedef int32_t xfs_tid_t; /* transaction identifier */
2047
2048-typedef __uint32_t xfs_dablk_t; /* dir/attr block number (in file) */
2049-typedef __uint32_t xfs_dahash_t; /* dir/attr hash value */
2050+typedef uint32_t xfs_dablk_t; /* dir/attr block number (in file) */
2051+typedef uint32_t xfs_dahash_t; /* dir/attr hash value */
2052
2053-typedef __uint64_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */
2054-typedef __uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */
2055-typedef __uint64_t xfs_rtblock_t; /* extent (block) in realtime area */
2056-typedef __uint64_t xfs_fileoff_t; /* block number in a file */
2057-typedef __uint64_t xfs_filblks_t; /* number of blocks in a file */
2058+typedef uint64_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */
2059+typedef uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */
2060+typedef uint64_t xfs_rtblock_t; /* extent (block) in realtime area */
2061+typedef uint64_t xfs_fileoff_t; /* block number in a file */
2062+typedef uint64_t xfs_filblks_t; /* number of blocks in a file */
2063
2064-typedef __int64_t xfs_srtblock_t; /* signed version of xfs_rtblock_t */
2065-typedef __int64_t xfs_sfiloff_t; /* signed block number in a file */
2066+typedef int64_t xfs_srtblock_t; /* signed version of xfs_rtblock_t */
2067+typedef int64_t xfs_sfiloff_t; /* signed block number in a file */
2068
2069 /*
2070 * Null values for the types.
2071@@ -125,7 +125,7 @@ struct xfs_name {
2072 * uid_t and gid_t are hard-coded to 32 bits in the inode.
2073 * Hence, an 'id' in a dquot is 32 bits..
2074 */
2075-typedef __uint32_t xfs_dqid_t;
2076+typedef uint32_t xfs_dqid_t;
2077
2078 /*
2079 * Constants for bit manipulations.
2080--
20812.14.1
2082
diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch b/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch
deleted file mode 100644
index 5e08f0d84..000000000
--- a/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch
+++ /dev/null
@@ -1,3800 +0,0 @@
1From 14f8b6810bd240cc58131483790a099fcf56c073 Mon Sep 17 00:00:00 2001
2From: "Darrick J. Wong" <darrick.wong@oracle.com>
3Date: Fri, 4 Aug 2017 16:33:51 -0500
4Subject: [PATCH] xfsprogs: remove double-underscore integer types
5
6This is a purely mechanical patch that removes the private
7__{u,}int{8,16,32,64}_t typedefs in favor of using the system
8{u,}int{8,16,32,64}_t typedefs. This is the sed script used to perform
9the transformation and fix the resulting whitespace and indentation
10errors:
11
12s/typedef\t__uint8_t/typedef __uint8_t\t/g
13s/typedef\t__uint/typedef __uint/g
14s/typedef\t__int\([0-9]*\)_t/typedef int\1_t\t/g
15s/__uint8_t\t/__uint8_t\t\t/g
16s/__uint/uint/g
17s/__int\([0-9]*\)_t\t/__int\1_t\t\t/g
18s/__int/int/g
19/^typedef.*int[0-9]*_t;$/d
20
21Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
22Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com>
23[sandeen: fix whitespace incidentals]
24Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
25Signed-off-by: Eric Sandeen <sandeen@sandeen.net>
26---
27 copy/xfs_copy.c | 14 ++++-----
28 copy/xfs_copy.h | 2 +-
29 db/attr.c | 8 ++---
30 db/attrshort.c | 4 +--
31 db/bit.c | 4 +--
32 db/bit.h | 2 +-
33 db/block.c | 8 ++---
34 db/check.c | 18 +++++------
35 db/convert.c | 28 ++++++++---------
36 db/faddr.c | 14 ++++-----
37 db/field.c | 44 +++++++++++++--------------
38 db/fprint.c | 8 ++---
39 db/frag.c | 8 ++---
40 db/inode.c | 34 ++++++++++-----------
41 db/io.c | 2 +-
42 db/io.h | 6 ++--
43 db/metadump.c | 12 ++++----
44 db/sb.c | 6 ++--
45 fsr/xfs_fsr.c | 2 +-
46 include/darwin.h | 18 +++++------
47 include/freebsd.h | 6 ++--
48 include/gnukfreebsd.h | 6 ++--
49 include/libxcmd.h | 6 ++--
50 include/linux.h | 8 ++---
51 include/xfs_arch.h | 22 +++++++-------
52 include/xfs_inode.h | 4 +--
53 include/xfs_log_recover.h | 2 +-
54 include/xfs_metadump.h | 4 +--
55 include/xfs_mount.h | 22 +++++++-------
56 libhandle/handle.c | 2 +-
57 libhandle/jdm.c | 2 +-
58 libxcmd/topology.c | 14 ++++-----
59 libxfs/darwin.c | 2 +-
60 libxfs/freebsd.c | 2 +-
61 libxfs/init.c | 2 +-
62 libxfs/irix.c | 2 +-
63 libxfs/libxfs_priv.h | 4 +--
64 libxfs/linux.c | 2 +-
65 libxfs/logitem.c | 2 +-
66 libxfs/radix-tree.c | 8 ++---
67 libxfs/rdwr.c | 6 ++--
68 libxfs/util.c | 8 ++---
69 logprint/log_misc.c | 6 ++--
70 mdrestore/xfs_mdrestore.c | 2 +-
71 mkfs/proto.c | 2 +-
72 mkfs/xfs_mkfs.c | 76 +++++++++++++++++++++++------------------------
73 quota/edit.c | 64 +++++++++++++++++++--------------------
74 quota/free.c | 44 +++++++++++++--------------
75 quota/quot.c | 24 +++++++--------
76 quota/quota.c | 4 +--
77 quota/quota.h | 12 ++++----
78 quota/report.c | 4 +--
79 quota/state.c | 2 +-
80 quota/util.c | 66 ++++++++++++++++++++--------------------
81 repair/README | 2 +-
82 repair/agheader.h | 14 ++++-----
83 repair/attr_repair.h | 26 ++++++++--------
84 repair/avl64.c | 38 ++++++++++++------------
85 repair/avl64.h | 18 +++++------
86 repair/dinode.c | 38 ++++++++++++------------
87 repair/dinode.h | 4 +--
88 repair/dir2.c | 2 +-
89 repair/globals.h | 18 +++++------
90 repair/incore.c | 10 +++----
91 repair/incore.h | 46 ++++++++++++++--------------
92 repair/incore_ext.c | 6 ++--
93 repair/incore_ino.c | 72 ++++++++++++++++++++++----------------------
94 repair/phase2.c | 2 +-
95 repair/phase3.c | 6 ++--
96 repair/phase4.c | 4 +--
97 repair/phase5.c | 28 ++++++++---------
98 repair/phase6.c | 16 +++++-----
99 repair/phase7.c | 6 ++--
100 repair/progress.c | 30 +++++++++----------
101 repair/progress.h | 4 +--
102 repair/rmap.c | 18 +++++------
103 repair/rmap.h | 2 +-
104 repair/sb.c | 24 +++++++--------
105 repair/scan.c | 50 +++++++++++++++----------------
106 repair/scan.h | 12 ++++----
107 80 files changed, 590 insertions(+), 590 deletions(-)
108
109diff --git a/copy/xfs_copy.c b/copy/xfs_copy.c
110index a7da824f..33e05dfd 100644
111--- a/copy/xfs_copy.c
112+++ b/copy/xfs_copy.c
113@@ -43,7 +43,7 @@ unsigned int source_sectorsize; /* source disk sectorsize */
114
115 xfs_agblock_t first_agbno;
116
117-__uint64_t barcount[11];
118+uint64_t barcount[11];
119
120 unsigned int num_targets;
121 target_control *target;
122@@ -313,7 +313,7 @@ usage(void)
123 }
124
125 void
126-init_bar(__uint64_t source_blocks)
127+init_bar(uint64_t source_blocks)
128 {
129 int i;
130
131@@ -322,7 +322,7 @@ init_bar(__uint64_t source_blocks)
132 }
133
134 int
135-bump_bar(int tenths, __uint64_t numblocks)
136+bump_bar(int tenths, uint64_t numblocks)
137 {
138 static char *bar[11] = {
139 " 0% ",
140@@ -534,8 +534,8 @@ main(int argc, char **argv)
141 xfs_off_t pos;
142 size_t length;
143 int c;
144- __uint64_t size, sizeb;
145- __uint64_t numblocks = 0;
146+ uint64_t size, sizeb;
147+ uint64_t numblocks = 0;
148 int wblocks = 0;
149 int num_threads = 0;
150 struct dioattr d;
151@@ -951,8 +951,8 @@ main(int argc, char **argv)
152 num_ags = mp->m_sb.sb_agcount;
153
154 init_bar(mp->m_sb.sb_blocksize / BBSIZE
155- * ((__uint64_t)mp->m_sb.sb_dblocks
156- - (__uint64_t)mp->m_sb.sb_fdblocks + 10 * num_ags));
157+ * ((uint64_t)mp->m_sb.sb_dblocks
158+ - (uint64_t)mp->m_sb.sb_fdblocks + 10 * num_ags));
159
160 kids = num_targets;
161
162diff --git a/copy/xfs_copy.h b/copy/xfs_copy.h
163index 27370688..53c6e42c 100644
164--- a/copy/xfs_copy.h
165+++ b/copy/xfs_copy.h
166@@ -76,7 +76,7 @@ typedef struct {
167
168 typedef int thread_id;
169 typedef int tm_index; /* index into thread mask array */
170-typedef __uint32_t thread_mask; /* a thread mask */
171+typedef uint32_t thread_mask; /* a thread mask */
172
173 typedef struct {
174 char *name;
175diff --git a/db/attr.c b/db/attr.c
176index 31536a8b..23ffcd5f 100644
177--- a/db/attr.c
178+++ b/db/attr.c
179@@ -77,16 +77,16 @@ const field_t attr_leaf_entry_flds[] = {
180 { "nameidx", FLDT_UINT16D, OI(LEOFF(nameidx)), C1, 0, TYP_NONE },
181 { "flags", FLDT_UINT8X, OI(LEOFF(flags)), C1, FLD_SKIPALL, TYP_NONE },
182 { "incomplete", FLDT_UINT1,
183- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_INCOMPLETE_BIT - 1), C1,
184+ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_INCOMPLETE_BIT - 1), C1,
185 0, TYP_NONE },
186 { "root", FLDT_UINT1,
187- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0,
188+ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0,
189 TYP_NONE },
190 { "secure", FLDT_UINT1,
191- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0,
192+ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0,
193 TYP_NONE },
194 { "local", FLDT_UINT1,
195- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_LOCAL_BIT - 1), C1, 0,
196+ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_LOCAL_BIT - 1), C1, 0,
197 TYP_NONE },
198 { "pad2", FLDT_UINT8X, OI(LEOFF(pad2)), C1, FLD_SKIPALL, TYP_NONE },
199 { NULL }
200diff --git a/db/attrshort.c b/db/attrshort.c
201index d82559cc..2ef358f5 100644
202--- a/db/attrshort.c
203+++ b/db/attrshort.c
204@@ -51,10 +51,10 @@ const field_t attr_sf_entry_flds[] = {
205 { "valuelen", FLDT_UINT8D, OI(EOFF(valuelen)), C1, 0, TYP_NONE },
206 { "flags", FLDT_UINT8X, OI(EOFF(flags)), C1, FLD_SKIPALL, TYP_NONE },
207 { "root", FLDT_UINT1,
208- OI(EOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0,
209+ OI(EOFF(flags) + bitsz(uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0,
210 TYP_NONE },
211 { "secure", FLDT_UINT1,
212- OI(EOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0,
213+ OI(EOFF(flags) + bitsz(uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0,
214 TYP_NONE },
215 { "name", FLDT_CHARNS, OI(EOFF(nameval)), attr_sf_entry_name_count,
216 FLD_COUNT, TYP_NONE },
217diff --git a/db/bit.c b/db/bit.c
218index 24872bf7..f5ebf681 100644
219--- a/db/bit.c
220+++ b/db/bit.c
221@@ -60,7 +60,7 @@ setbit(
222 }
223 }
224
225-__int64_t
226+int64_t
227 getbitval(
228 void *obj,
229 int bitoff,
230@@ -70,7 +70,7 @@ getbitval(
231 int bit;
232 int i;
233 char *p;
234- __int64_t rval;
235+ int64_t rval;
236 int signext;
237 int z1, z2, z3, z4;
238
239diff --git a/db/bit.h b/db/bit.h
240index 80ba24c4..9fd71f4b 100644
241--- a/db/bit.h
242+++ b/db/bit.h
243@@ -25,5 +25,5 @@
244 #define BVUNSIGNED 0
245 #define BVSIGNED 1
246
247-extern __int64_t getbitval(void *obj, int bitoff, int nbits, int flags);
248+extern int64_t getbitval(void *obj, int bitoff, int nbits, int flags);
249 extern void setbitval(void *obuf, int bitoff, int nbits, void *ibuf);
250diff --git a/db/block.c b/db/block.c
251index 4a357ced..5ecd687a 100644
252--- a/db/block.c
253+++ b/db/block.c
254@@ -98,7 +98,7 @@ ablock_f(
255 }
256 dfsbno = bm.startblock + (bno - bm.startoff);
257 ASSERT(typtab[TYP_ATTR].typnm == TYP_ATTR);
258- set_cur(&typtab[TYP_ATTR], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno),
259+ set_cur(&typtab[TYP_ATTR], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno),
260 blkbb, DB_RING_ADD, NULL);
261 return 0;
262 }
263@@ -128,14 +128,14 @@ daddr_f(
264 int argc,
265 char **argv)
266 {
267- __int64_t d;
268+ int64_t d;
269 char *p;
270
271 if (argc == 1) {
272 dbprintf(_("current daddr is %lld\n"), iocur_top->off >> BBSHIFT);
273 return 0;
274 }
275- d = (__int64_t)strtoull(argv[1], &p, 0);
276+ d = (int64_t)strtoull(argv[1], &p, 0);
277 if (*p != '\0' ||
278 d >= mp->m_sb.sb_dblocks << (mp->m_sb.sb_blocklog - BBSHIFT)) {
279 dbprintf(_("bad daddr %s\n"), argv[1]);
280@@ -197,7 +197,7 @@ dblock_f(
281 ASSERT(typtab[type].typnm == type);
282 if (nex > 1)
283 make_bbmap(&bbmap, nex, bmp);
284- set_cur(&typtab[type], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno),
285+ set_cur(&typtab[type], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno),
286 nb * blkbb, DB_RING_ADD, nex > 1 ? &bbmap : NULL);
287 free(bmp);
288 return 0;
289diff --git a/db/check.c b/db/check.c
290index 8e618a23..81ba63a6 100644
291--- a/db/check.c
292+++ b/db/check.c
293@@ -114,8 +114,8 @@ typedef struct dirhash {
294
295 static xfs_extlen_t agffreeblks;
296 static xfs_extlen_t agflongest;
297-static __uint64_t agf_aggr_freeblks; /* aggregate count over all */
298-static __uint32_t agfbtreeblks;
299+static uint64_t agf_aggr_freeblks; /* aggregate count over all */
300+static uint32_t agfbtreeblks;
301 static int lazycount;
302 static xfs_agino_t agicount;
303 static xfs_agino_t agifreecount;
304@@ -124,10 +124,10 @@ static int blist_size;
305 static char **dbmap; /* really dbm_t:8 */
306 static dirhash_t **dirhash;
307 static int error;
308-static __uint64_t fdblocks;
309-static __uint64_t frextents;
310-static __uint64_t icount;
311-static __uint64_t ifree;
312+static uint64_t fdblocks;
313+static uint64_t frextents;
314+static uint64_t icount;
315+static uint64_t ifree;
316 static inodata_t ***inodata;
317 static int inodata_hash_size;
318 static inodata_t ***inomap;
319@@ -1187,7 +1187,7 @@ blocktrash_f(
320 goto out;
321 }
322 for (i = 0; i < count; i++) {
323- randb = (xfs_rfsblock_t)((((__int64_t)random() << 32) |
324+ randb = (xfs_rfsblock_t)((((int64_t)random() << 32) |
325 random()) % blocks);
326 for (bi = 0, agno = 0, done = 0;
327 !done && agno < mp->m_sb.sb_agcount;
328@@ -3032,7 +3032,7 @@ process_leaf_node_dir_v2(
329 }
330 if (v)
331 dbprintf(_("dir inode %lld block %u=%llu\n"), id->ino,
332- (__uint32_t)dbno,
333+ (uint32_t)dbno,
334 (xfs_fsblock_t)bmp->startblock);
335 push_cur();
336 if (nex > 1)
337@@ -3045,7 +3045,7 @@ process_leaf_node_dir_v2(
338 if (!sflag || v)
339 dbprintf(_("can't read block %u for directory "
340 "inode %lld\n"),
341- (__uint32_t)dbno, id->ino);
342+ (uint32_t)dbno, id->ino);
343 error++;
344 pop_cur();
345 dbno += mp->m_dir_geo->fsbcount - 1;
346diff --git a/db/convert.c b/db/convert.c
347index a337abea..fa4f9623 100644
348--- a/db/convert.c
349+++ b/db/convert.c
350@@ -24,13 +24,13 @@
351
352 #define M(A) (1 << CT_ ## A)
353 #define agblock_to_bytes(x) \
354- ((__uint64_t)(x) << mp->m_sb.sb_blocklog)
355+ ((uint64_t)(x) << mp->m_sb.sb_blocklog)
356 #define agino_to_bytes(x) \
357- ((__uint64_t)(x) << mp->m_sb.sb_inodelog)
358+ ((uint64_t)(x) << mp->m_sb.sb_inodelog)
359 #define agnumber_to_bytes(x) \
360- agblock_to_bytes((__uint64_t)(x) * mp->m_sb.sb_agblocks)
361+ agblock_to_bytes((uint64_t)(x) * mp->m_sb.sb_agblocks)
362 #define daddr_to_bytes(x) \
363- ((__uint64_t)(x) << BBSHIFT)
364+ ((uint64_t)(x) << BBSHIFT)
365 #define fsblock_to_bytes(x) \
366 (agnumber_to_bytes(XFS_FSB_TO_AGNO(mp, (x))) + \
367 agblock_to_bytes(XFS_FSB_TO_AGBNO(mp, (x))))
368@@ -38,7 +38,7 @@
369 (agnumber_to_bytes(XFS_INO_TO_AGNO(mp, (x))) + \
370 agino_to_bytes(XFS_INO_TO_AGINO(mp, (x))))
371 #define inoidx_to_bytes(x) \
372- ((__uint64_t)(x) << mp->m_sb.sb_inodelog)
373+ ((uint64_t)(x) << mp->m_sb.sb_inodelog)
374
375 typedef enum {
376 CT_NONE = -1,
377@@ -68,7 +68,7 @@ typedef union {
378 xfs_agnumber_t agnumber;
379 int bboff;
380 int blkoff;
381- __uint64_t byte;
382+ uint64_t byte;
383 xfs_daddr_t daddr;
384 xfs_fsblock_t fsblock;
385 xfs_ino_t ino;
386@@ -76,7 +76,7 @@ typedef union {
387 int inooff;
388 } cval_t;
389
390-static __uint64_t bytevalue(ctype_t ctype, cval_t *val);
391+static uint64_t bytevalue(ctype_t ctype, cval_t *val);
392 static int convert_f(int argc, char **argv);
393 static int getvalue(char *s, ctype_t ctype, cval_t *val);
394 static ctype_t lookupcty(char *ctyname);
395@@ -118,7 +118,7 @@ static const cmdinfo_t convert_cmd =
396 { "convert", NULL, convert_f, 3, 9, 0, "type num [type num]... type",
397 "convert from one address form to another", NULL };
398
399-static __uint64_t
400+static uint64_t
401 bytevalue(ctype_t ctype, cval_t *val)
402 {
403 switch (ctype) {
404@@ -129,9 +129,9 @@ bytevalue(ctype_t ctype, cval_t *val)
405 case CT_AGNUMBER:
406 return agnumber_to_bytes(val->agnumber);
407 case CT_BBOFF:
408- return (__uint64_t)val->bboff;
409+ return (uint64_t)val->bboff;
410 case CT_BLKOFF:
411- return (__uint64_t)val->blkoff;
412+ return (uint64_t)val->blkoff;
413 case CT_BYTE:
414 return val->byte;
415 case CT_DADDR:
416@@ -143,7 +143,7 @@ bytevalue(ctype_t ctype, cval_t *val)
417 case CT_INOIDX:
418 return inoidx_to_bytes(val->inoidx);
419 case CT_INOOFF:
420- return (__uint64_t)val->inooff;
421+ return (uint64_t)val->inooff;
422 case CT_NONE:
423 case NCTS:
424 break;
425@@ -160,7 +160,7 @@ convert_f(int argc, char **argv)
426 cval_t cvals[NCTS] = {};
427 int i;
428 int mask;
429- __uint64_t v;
430+ uint64_t v;
431 ctype_t wtype;
432
433 /* move past the "convert" command */
434@@ -262,7 +262,7 @@ static int
435 getvalue(char *s, ctype_t ctype, cval_t *val)
436 {
437 char *p;
438- __uint64_t v;
439+ uint64_t v;
440
441 v = strtoull(s, &p, 0);
442 if (*p != '\0') {
443@@ -286,7 +286,7 @@ getvalue(char *s, ctype_t ctype, cval_t *val)
444 val->blkoff = (int)v;
445 break;
446 case CT_BYTE:
447- val->byte = (__uint64_t)v;
448+ val->byte = (uint64_t)v;
449 break;
450 case CT_DADDR:
451 val->daddr = (xfs_daddr_t)v;
452diff --git a/db/faddr.c b/db/faddr.c
453index 877200bf..56207648 100644
454--- a/db/faddr.c
455+++ b/db/faddr.c
456@@ -79,11 +79,11 @@ fa_attrblock(
457 typnm_t next)
458 {
459 bmap_ext_t bm;
460- __uint32_t bno;
461+ uint32_t bno;
462 xfs_fsblock_t dfsbno;
463 int nex;
464
465- bno = (__uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
466+ bno = (uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
467 if (bno == 0) {
468 dbprintf(_("null attribute block number, cannot set new addr\n"));
469 return;
470@@ -96,7 +96,7 @@ fa_attrblock(
471 }
472 dfsbno = bm.startblock + (bno - bm.startoff);
473 ASSERT(typtab[next].typnm == next);
474- set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), blkbb,
475+ set_cur(&typtab[next], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), blkbb,
476 DB_RING_ADD, NULL);
477 }
478
479@@ -276,11 +276,11 @@ fa_dirblock(
480 {
481 bbmap_t bbmap;
482 bmap_ext_t *bmp;
483- __uint32_t bno;
484+ uint32_t bno;
485 xfs_fsblock_t dfsbno;
486 int nex;
487
488- bno = (__uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
489+ bno = (uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED);
490 if (bno == 0) {
491 dbprintf(_("null directory block number, cannot set new addr\n"));
492 return;
493@@ -297,7 +297,7 @@ fa_dirblock(
494 ASSERT(typtab[next].typnm == next);
495 if (nex > 1)
496 make_bbmap(&bbmap, nex, bmp);
497- set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno),
498+ set_cur(&typtab[next], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno),
499 XFS_FSB_TO_BB(mp, mp->m_dir_geo->fsbcount), DB_RING_ADD,
500 nex > 1 ? &bbmap : NULL);
501 free(bmp);
502@@ -317,7 +317,7 @@ fa_drfsbno(
503 return;
504 }
505 ASSERT(typtab[next].typnm == next);
506- set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_BB(mp, bno), blkbb,
507+ set_cur(&typtab[next], (int64_t)XFS_FSB_TO_BB(mp, bno), blkbb,
508 DB_RING_ADD, NULL);
509 }
510
511diff --git a/db/field.c b/db/field.c
512index 865b0b71..f1e5f35e 100644
513--- a/db/field.c
514+++ b/db/field.c
515@@ -83,7 +83,7 @@ const ftattr_t ftattrtab[] = {
516 attr_sf_entry_size, FTARG_SIZE, NULL, attr_sf_entry_flds },
517 { FLDT_ATTR_SF_HDR, "attr_sf_hdr", NULL, (char *)attr_sf_hdr_flds,
518 SI(bitsz(struct xfs_attr_sf_hdr)), 0, NULL, attr_sf_hdr_flds },
519- { FLDT_ATTRBLOCK, "attrblock", fp_num, "%u", SI(bitsz(__uint32_t)), 0,
520+ { FLDT_ATTRBLOCK, "attrblock", fp_num, "%u", SI(bitsz(uint32_t)), 0,
521 fa_attrblock, NULL },
522 { FLDT_ATTRSHORT, "attrshort", NULL, (char *)attr_shortform_flds,
523 attrshort_size, FTARG_SIZE, NULL, attr_shortform_flds },
524@@ -199,7 +199,7 @@ const ftattr_t ftattrtab[] = {
525 SI(bitsz(struct xfs_refcount_rec)), 0, NULL, refcbt_rec_flds },
526
527 /* CRC field */
528- { FLDT_CRC, "crc", fp_crc, "%#x (%s)", SI(bitsz(__uint32_t)),
529+ { FLDT_CRC, "crc", fp_crc, "%#x (%s)", SI(bitsz(uint32_t)),
530 0, NULL, NULL },
531
532 { FLDT_DEV, "dev", fp_num, "%#x", SI(bitsz(xfs_dev_t)), 0, NULL, NULL },
533@@ -214,7 +214,7 @@ const ftattr_t ftattrtab[] = {
534 { FLDT_DINODE_CORE, "dinode_core", NULL, (char *)inode_core_flds,
535 SI(bitsz(xfs_dinode_t)), 0, NULL, inode_core_flds },
536 { FLDT_DINODE_FMT, "dinode_fmt", fp_dinode_fmt, NULL,
537- SI(bitsz(__int8_t)), 0, NULL, NULL },
538+ SI(bitsz(int8_t)), 0, NULL, NULL },
539 { FLDT_DINODE_U, "dinode_u", NULL, (char *)inode_u_flds, inode_u_size,
540 FTARG_SIZE|FTARG_OKEMPTY, NULL, inode_u_flds },
541 { FLDT_DINODE_V3, "dinode_v3", NULL, (char *)inode_v3_flds,
542@@ -295,7 +295,7 @@ const ftattr_t ftattrtab[] = {
543 { FLDT_DA3_NODE_HDR, "dir_node_hdr", NULL, (char *)da3_node_hdr_flds,
544 SI(bitsz(struct xfs_da3_node_hdr)), 0, NULL, da3_node_hdr_flds },
545
546- { FLDT_DIRBLOCK, "dirblock", fp_num, "%u", SI(bitsz(__uint32_t)), 0,
547+ { FLDT_DIRBLOCK, "dirblock", fp_num, "%u", SI(bitsz(uint32_t)), 0,
548 fa_dirblock, NULL },
549 { FLDT_DISK_DQUOT, "disk_dquot", NULL, (char *)disk_dquot_flds,
550 SI(bitsz(xfs_disk_dquot_t)), 0, NULL, disk_dquot_flds },
551@@ -335,15 +335,15 @@ const ftattr_t ftattrtab[] = {
552 FTARG_SIZE, NULL, inode_crc_flds },
553 { FLDT_INOFREE, "inofree", fp_num, "%#llx", SI(bitsz(xfs_inofree_t)), 0,
554 NULL, NULL },
555- { FLDT_INT16D, "int16d", fp_num, "%d", SI(bitsz(__int16_t)),
556+ { FLDT_INT16D, "int16d", fp_num, "%d", SI(bitsz(int16_t)),
557 FTARG_SIGNED, NULL, NULL },
558- { FLDT_INT32D, "int32d", fp_num, "%d", SI(bitsz(__int32_t)),
559+ { FLDT_INT32D, "int32d", fp_num, "%d", SI(bitsz(int32_t)),
560 FTARG_SIGNED, NULL, NULL },
561- { FLDT_INT64D, "int64d", fp_num, "%lld", SI(bitsz(__int64_t)),
562+ { FLDT_INT64D, "int64d", fp_num, "%lld", SI(bitsz(int64_t)),
563 FTARG_SIGNED, NULL, NULL },
564- { FLDT_INT8D, "int8d", fp_num, "%d", SI(bitsz(__int8_t)), FTARG_SIGNED,
565+ { FLDT_INT8D, "int8d", fp_num, "%d", SI(bitsz(int8_t)), FTARG_SIGNED,
566 NULL, NULL },
567- { FLDT_NSEC, "nsec", fp_num, "%09d", SI(bitsz(__int32_t)), FTARG_SIGNED,
568+ { FLDT_NSEC, "nsec", fp_num, "%09d", SI(bitsz(int32_t)), FTARG_SIGNED,
569 NULL, NULL },
570 { FLDT_QCNT, "qcnt", fp_num, "%llu", SI(bitsz(xfs_qcnt_t)), 0, NULL,
571 NULL },
572@@ -356,34 +356,34 @@ const ftattr_t ftattrtab[] = {
573 { FLDT_SYMLINK_CRC, "symlink", NULL, (char *)symlink_crc_flds,
574 symlink_size, FTARG_SIZE, NULL, symlink_crc_flds },
575
576- { FLDT_TIME, "time", fp_time, NULL, SI(bitsz(__int32_t)), FTARG_SIGNED,
577+ { FLDT_TIME, "time", fp_time, NULL, SI(bitsz(int32_t)), FTARG_SIGNED,
578 NULL, NULL },
579 { FLDT_TIMESTAMP, "timestamp", NULL, (char *)timestamp_flds,
580 SI(bitsz(xfs_timestamp_t)), 0, NULL, timestamp_flds },
581 { FLDT_UINT1, "uint1", fp_num, "%u", SI(1), 0, NULL, NULL },
582- { FLDT_UINT16D, "uint16d", fp_num, "%u", SI(bitsz(__uint16_t)), 0, NULL,
583+ { FLDT_UINT16D, "uint16d", fp_num, "%u", SI(bitsz(uint16_t)), 0, NULL,
584 NULL },
585- { FLDT_UINT16O, "uint16o", fp_num, "%#o", SI(bitsz(__uint16_t)), 0,
586+ { FLDT_UINT16O, "uint16o", fp_num, "%#o", SI(bitsz(uint16_t)), 0,
587 NULL, NULL },
588- { FLDT_UINT16X, "uint16x", fp_num, "%#x", SI(bitsz(__uint16_t)), 0,
589+ { FLDT_UINT16X, "uint16x", fp_num, "%#x", SI(bitsz(uint16_t)), 0,
590 NULL, NULL },
591- { FLDT_UINT32D, "uint32d", fp_num, "%u", SI(bitsz(__uint32_t)), 0, NULL,
592+ { FLDT_UINT32D, "uint32d", fp_num, "%u", SI(bitsz(uint32_t)), 0, NULL,
593 NULL },
594- { FLDT_UINT32O, "uint32o", fp_num, "%#o", SI(bitsz(__uint32_t)), 0,
595+ { FLDT_UINT32O, "uint32o", fp_num, "%#o", SI(bitsz(uint32_t)), 0,
596 NULL, NULL },
597- { FLDT_UINT32X, "uint32x", fp_num, "%#x", SI(bitsz(__uint32_t)), 0,
598+ { FLDT_UINT32X, "uint32x", fp_num, "%#x", SI(bitsz(uint32_t)), 0,
599 NULL, NULL },
600- { FLDT_UINT64D, "uint64d", fp_num, "%llu", SI(bitsz(__uint64_t)), 0,
601+ { FLDT_UINT64D, "uint64d", fp_num, "%llu", SI(bitsz(uint64_t)), 0,
602 NULL, NULL },
603- { FLDT_UINT64O, "uint64o", fp_num, "%#llo", SI(bitsz(__uint64_t)), 0,
604+ { FLDT_UINT64O, "uint64o", fp_num, "%#llo", SI(bitsz(uint64_t)), 0,
605 NULL, NULL },
606- { FLDT_UINT64X, "uint64x", fp_num, "%#llx", SI(bitsz(__uint64_t)), 0,
607+ { FLDT_UINT64X, "uint64x", fp_num, "%#llx", SI(bitsz(uint64_t)), 0,
608 NULL, NULL },
609- { FLDT_UINT8D, "uint8d", fp_num, "%u", SI(bitsz(__uint8_t)), 0, NULL,
610+ { FLDT_UINT8D, "uint8d", fp_num, "%u", SI(bitsz(uint8_t)), 0, NULL,
611 NULL },
612- { FLDT_UINT8O, "uint8o", fp_num, "%#o", SI(bitsz(__uint8_t)), 0, NULL,
613+ { FLDT_UINT8O, "uint8o", fp_num, "%#o", SI(bitsz(uint8_t)), 0, NULL,
614 NULL },
615- { FLDT_UINT8X, "uint8x", fp_num, "%#x", SI(bitsz(__uint8_t)), 0, NULL,
616+ { FLDT_UINT8X, "uint8x", fp_num, "%#x", SI(bitsz(uint8_t)), 0, NULL,
617 NULL },
618 { FLDT_UUID, "uuid", fp_uuid, NULL, SI(bitsz(uuid_t)), 0, NULL, NULL },
619 { FLDT_ZZZ, NULL }
620diff --git a/db/fprint.c b/db/fprint.c
621index fd7e7f45..261a31ef 100644
622--- a/db/fprint.c
623+++ b/db/fprint.c
624@@ -80,7 +80,7 @@ fp_num(
625 int bitpos;
626 int i;
627 int isnull;
628- __int64_t val;
629+ int64_t val;
630
631 for (i = 0, bitpos = bit;
632 i < count && !seenint();
633@@ -100,7 +100,7 @@ fp_num(
634 else if (size > 32)
635 dbprintf(fmtstr, val);
636 else
637- dbprintf(fmtstr, (__int32_t)val);
638+ dbprintf(fmtstr, (int32_t)val);
639 if (i < count - 1)
640 dbprintf(" ");
641 }
642@@ -203,7 +203,7 @@ fp_crc(
643 {
644 int bitpos;
645 int i;
646- __int64_t val;
647+ int64_t val;
648 char *ok;
649
650 switch (iocur_crc_valid()) {
651@@ -230,7 +230,7 @@ fp_crc(
652 if (size > 32)
653 dbprintf(fmtstr, val, ok);
654 else
655- dbprintf(fmtstr, (__int32_t)val, ok);
656+ dbprintf(fmtstr, (int32_t)val, ok);
657 if (i < count - 1)
658 dbprintf(" ");
659 }
660diff --git a/db/frag.c b/db/frag.c
661index 8005e45d..d224f0c2 100644
662--- a/db/frag.c
663+++ b/db/frag.c
664@@ -42,8 +42,8 @@ typedef struct extmap {
665
666 static int aflag;
667 static int dflag;
668-static __uint64_t extcount_actual;
669-static __uint64_t extcount_ideal;
670+static uint64_t extcount_actual;
671+static uint64_t extcount_ideal;
672 static int fflag;
673 static int lflag;
674 static int qflag;
675@@ -310,8 +310,8 @@ process_inode(
676 xfs_agino_t agino,
677 xfs_dinode_t *dip)
678 {
679- __uint64_t actual;
680- __uint64_t ideal;
681+ uint64_t actual;
682+ uint64_t ideal;
683 xfs_ino_t ino;
684 int skipa;
685 int skipd;
686diff --git a/db/inode.c b/db/inode.c
687index 8b7a41e4..6cc47d6a 100644
688--- a/db/inode.c
689+++ b/db/inode.c
690@@ -119,49 +119,49 @@ const field_t inode_core_flds[] = {
691 { "dmstate", FLDT_UINT16D, OI(COFF(dmstate)), C1, 0, TYP_NONE },
692 { "flags", FLDT_UINT16X, OI(COFF(flags)), C1, FLD_SKIPALL, TYP_NONE },
693 { "newrtbm", FLDT_UINT1,
694- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NEWRTBM_BIT - 1), C1,
695+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NEWRTBM_BIT - 1), C1,
696 0, TYP_NONE },
697 { "prealloc", FLDT_UINT1,
698- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_PREALLOC_BIT - 1), C1,
699+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_PREALLOC_BIT - 1), C1,
700 0, TYP_NONE },
701 { "realtime", FLDT_UINT1,
702- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_REALTIME_BIT - 1), C1,
703+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_REALTIME_BIT - 1), C1,
704 0, TYP_NONE },
705 { "immutable", FLDT_UINT1,
706- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_IMMUTABLE_BIT-1), C1,
707+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_IMMUTABLE_BIT-1), C1,
708 0, TYP_NONE },
709 { "append", FLDT_UINT1,
710- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_APPEND_BIT - 1), C1,
711+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_APPEND_BIT - 1), C1,
712 0, TYP_NONE },
713 { "sync", FLDT_UINT1,
714- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_SYNC_BIT - 1), C1,
715+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_SYNC_BIT - 1), C1,
716 0, TYP_NONE },
717 { "noatime", FLDT_UINT1,
718- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NOATIME_BIT - 1), C1,
719+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NOATIME_BIT - 1), C1,
720 0, TYP_NONE },
721 { "nodump", FLDT_UINT1,
722- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NODUMP_BIT - 1), C1,
723+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NODUMP_BIT - 1), C1,
724 0, TYP_NONE },
725 { "rtinherit", FLDT_UINT1,
726- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_RTINHERIT_BIT-1), C1,
727+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_RTINHERIT_BIT-1), C1,
728 0, TYP_NONE },
729 { "projinherit", FLDT_UINT1,
730- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_PROJINHERIT_BIT-1),C1,
731+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_PROJINHERIT_BIT-1), C1,
732 0, TYP_NONE },
733 { "nosymlinks", FLDT_UINT1,
734- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NOSYMLINKS_BIT-1), C1,
735+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NOSYMLINKS_BIT-1), C1,
736 0, TYP_NONE },
737 { "extsz", FLDT_UINT1,
738- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_EXTSIZE_BIT-1),C1,
739+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_EXTSIZE_BIT-1), C1,
740 0, TYP_NONE },
741 { "extszinherit", FLDT_UINT1,
742- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_EXTSZINHERIT_BIT-1),C1,
743+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_EXTSZINHERIT_BIT-1), C1,
744 0, TYP_NONE },
745 { "nodefrag", FLDT_UINT1,
746- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NODEFRAG_BIT-1),C1,
747+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NODEFRAG_BIT-1), C1,
748 0, TYP_NONE },
749 { "filestream", FLDT_UINT1,
750- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_FILESTREAM_BIT-1),C1,
751+ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_FILESTREAM_BIT-1), C1,
752 0, TYP_NONE },
753 { "gen", FLDT_UINT32D, OI(COFF(gen)), C1, 0, TYP_NONE },
754 { NULL }
755@@ -177,10 +177,10 @@ const field_t inode_v3_flds[] = {
756 { "inumber", FLDT_INO, OI(COFF(ino)), C1, 0, TYP_NONE },
757 { "uuid", FLDT_UUID, OI(COFF(uuid)), C1, 0, TYP_NONE },
758 { "reflink", FLDT_UINT1,
759- OI(COFF(flags2) + bitsz(__uint64_t) - XFS_DIFLAG2_REFLINK_BIT-1), C1,
760+ OI(COFF(flags2) + bitsz(uint64_t) - XFS_DIFLAG2_REFLINK_BIT-1), C1,
761 0, TYP_NONE },
762 { "cowextsz", FLDT_UINT1,
763- OI(COFF(flags2) + bitsz(__uint64_t) - XFS_DIFLAG2_COWEXTSIZE_BIT-1), C1,
764+ OI(COFF(flags2) + bitsz(uint64_t) - XFS_DIFLAG2_COWEXTSIZE_BIT-1), C1,
765 0, TYP_NONE },
766 { NULL }
767 };
768diff --git a/db/io.c b/db/io.c
769index 1f27f6b3..fd9b9f4b 100644
770--- a/db/io.c
771+++ b/db/io.c
772@@ -545,7 +545,7 @@ set_cur(
773 struct xfs_buf *bp;
774 xfs_ino_t dirino;
775 xfs_ino_t ino;
776- __uint16_t mode;
777+ uint16_t mode;
778 const struct xfs_buf_ops *ops = type ? type->bops : NULL;
779
780 if (iocur_sp < 0) {
781diff --git a/db/io.h b/db/io.h
782index 99730048..df0fdd75 100644
783--- a/db/io.h
784+++ b/db/io.h
785@@ -25,7 +25,7 @@ typedef struct bbmap {
786 } bbmap_t;
787
788 typedef struct iocur {
789- __int64_t bb; /* BB number in filesystem of buf */
790+ int64_t bb; /* BB number in filesystem of buf */
791 int blen; /* length of "buf", bb's */
792 int boff; /* data - buf */
793 void *buf; /* base address of buffer */
794@@ -33,7 +33,7 @@ typedef struct iocur {
795 xfs_ino_t dirino; /* current directory inode number */
796 xfs_ino_t ino; /* current inode number */
797 int len; /* length of "data", bytes */
798- __uint16_t mode; /* current inode's mode */
799+ uint16_t mode; /* current inode's mode */
800 xfs_off_t off; /* fs offset of "data" in bytes */
801 const struct typ *typ; /* type of "data" */
802 bbmap_t *bbmap; /* map daddr if fragmented */
803@@ -57,7 +57,7 @@ extern void off_cur(int off, int len);
804 extern void pop_cur(void);
805 extern void print_iocur(char *tag, iocur_t *ioc);
806 extern void push_cur(void);
807-extern int read_buf(__int64_t daddr, int count, void *bufp);
808+extern int read_buf(int64_t daddr, int count, void *bufp);
809 extern void write_cur(void);
810 extern void set_cur(const struct typ *type, xfs_daddr_t blknum,
811 int len, int ring_add, bbmap_t *bbmap);
812diff --git a/db/metadump.c b/db/metadump.c
813index 31bb5959..67bdf14e 100644
814--- a/db/metadump.c
815+++ b/db/metadump.c
816@@ -175,7 +175,7 @@ write_index(void)
817 static int
818 write_buf_segment(
819 char *data,
820- __int64_t off,
821+ int64_t off,
822 int len)
823 {
824 int i;
825@@ -1256,7 +1256,7 @@ process_sf_dir(
826 {
827 struct xfs_dir2_sf_hdr *sfp;
828 xfs_dir2_sf_entry_t *sfep;
829- __uint64_t ino_dir_size;
830+ uint64_t ino_dir_size;
831 int i;
832
833 sfp = (struct xfs_dir2_sf_hdr *)XFS_DFORK_DPTR(dip);
834@@ -1322,7 +1322,7 @@ process_sf_dir(
835 static void
836 obfuscate_path_components(
837 char *buf,
838- __uint64_t len)
839+ uint64_t len)
840 {
841 unsigned char *comp = (unsigned char *)buf;
842 unsigned char *end = comp + len;
843@@ -1359,7 +1359,7 @@ static void
844 process_sf_symlink(
845 xfs_dinode_t *dip)
846 {
847- __uint64_t len;
848+ uint64_t len;
849 char *buf;
850
851 len = be64_to_cpu(dip->di_size);
852@@ -1631,7 +1631,7 @@ process_attr_block(
853 xfs_attr_leaf_entry_t *entry;
854 xfs_attr_leaf_name_local_t *local;
855 xfs_attr_leaf_name_remote_t *remote;
856- __uint32_t bs = mp->m_sb.sb_blocksize;
857+ uint32_t bs = mp->m_sb.sb_blocksize;
858 char *first_name;
859
860
861@@ -2270,7 +2270,7 @@ done:
862 return success;
863 }
864
865-static __uint32_t inodes_copied = 0;
866+static uint32_t inodes_copied;
867
868 static int
869 copy_inode_chunk(
870diff --git a/db/sb.c b/db/sb.c
871index 8e7722cd..f19248d7 100644
872--- a/db/sb.c
873+++ b/db/sb.c
874@@ -606,7 +606,7 @@ version_help(void)
875 }
876
877 static int
878-do_version(xfs_agnumber_t agno, __uint16_t version, __uint32_t features)
879+do_version(xfs_agnumber_t agno, uint16_t version, uint32_t features)
880 {
881 xfs_sb_t tsb;
882
883@@ -710,8 +710,8 @@ version_f(
884 int argc,
885 char **argv)
886 {
887- __uint16_t version = 0;
888- __uint32_t features = 0;
889+ uint16_t version = 0;
890+ uint32_t features = 0;
891 xfs_agnumber_t ag;
892
893 if (argc == 2) { /* WRITE VERSION */
894diff --git a/fsr/xfs_fsr.c b/fsr/xfs_fsr.c
895index 517b75f0..d4846a32 100644
896--- a/fsr/xfs_fsr.c
897+++ b/fsr/xfs_fsr.c
898@@ -54,7 +54,7 @@ struct getbmap *outmap = NULL;
899 int outmap_size = 0;
900 int RealUid;
901 int tmp_agi;
902-static __int64_t minimumfree = 2048;
903+static int64_t minimumfree = 2048;
904
905 #define MNTTYPE_XFS "xfs"
906
907diff --git a/include/darwin.h b/include/darwin.h
908index 7bbd5764..51031c42 100644
909--- a/include/darwin.h
910+++ b/include/darwin.h
911@@ -125,15 +125,15 @@ typedef signed int __s32;
912 typedef unsigned long long int __u64;
913 typedef signed long long int __s64;
914
915-#define __int8_t int8_t
916-#define __int16_t int16_t
917-#define __int32_t int32_t
918-#define __int32_t int32_t
919-#define __int64_t int64_t
920-#define __uint8_t u_int8_t
921-#define __uint16_t u_int16_t
922-#define __uint32_t u_int32_t
923-#define __uint64_t u_int64_t
924+#define int8_t int8_t
925+#define int16_t int16_t
926+#define int32_t int32_t
927+#define int32_t int32_t
928+#define int64_t int64_t
929+#define uint8_t u_int8_t
930+#define uint16_t u_int16_t
931+#define uint32_t u_int32_t
932+#define uint64_t u_int64_t
933
934 typedef off_t xfs_off_t;
935 typedef u_int64_t xfs_ino_t;
936diff --git a/include/freebsd.h b/include/freebsd.h
937index fb318b89..f52ed0a9 100644
938--- a/include/freebsd.h
939+++ b/include/freebsd.h
940@@ -50,9 +50,9 @@ typedef unsigned long long int __u64;
941 typedef signed long long int __s64;
942
943 typedef off_t xfs_off_t;
944-typedef __uint64_t xfs_ino_t;
945-typedef __uint32_t xfs_dev_t;
946-typedef __int64_t xfs_daddr_t;
947+typedef uint64_t xfs_ino_t;
948+typedef uint32_t xfs_dev_t;
949+typedef int64_t xfs_daddr_t;
950 typedef __u32 xfs_nlink_t;
951
952 #define O_LARGEFILE 0
953diff --git a/include/gnukfreebsd.h b/include/gnukfreebsd.h
954index 6916e65a..1db3f4f0 100644
955--- a/include/gnukfreebsd.h
956+++ b/include/gnukfreebsd.h
957@@ -46,9 +46,9 @@ typedef unsigned long long int __u64;
958 typedef signed long long int __s64;
959
960 typedef off_t xfs_off_t;
961-typedef __uint64_t xfs_ino_t;
962-typedef __uint32_t xfs_dev_t;
963-typedef __int64_t xfs_daddr_t;
964+typedef uint64_t xfs_ino_t;
965+typedef uint32_t xfs_dev_t;
966+typedef int64_t xfs_daddr_t;
967 typedef __u32 xfs_nlink_t;
968
969 #define HAVE_FID 1
970diff --git a/include/libxcmd.h b/include/libxcmd.h
971index e8d2ffc8..6806380c 100644
972--- a/include/libxcmd.h
973+++ b/include/libxcmd.h
974@@ -42,10 +42,10 @@ get_topology(
975 extern void
976 calc_default_ag_geometry(
977 int blocklog,
978- __uint64_t dblocks,
979+ uint64_t dblocks,
980 int multidisk,
981- __uint64_t *agsize,
982- __uint64_t *agcount);
983+ uint64_t *agsize,
984+ uint64_t *agcount);
985
986 extern int
987 check_overwrite(
988diff --git a/include/linux.h b/include/linux.h
989index 9611a37f..6ce344c5 100644
990--- a/include/linux.h
991+++ b/include/linux.h
992@@ -132,7 +132,7 @@ static __inline__ void platform_uuid_copy(uuid_t *dst, uuid_t *src)
993 static __inline__ int
994 platform_discard_blocks(int fd, uint64_t start, uint64_t len)
995 {
996- __uint64_t range[2] = { start, len };
997+ uint64_t range[2] = { start, len };
998
999 if (ioctl(fd, BLKDISCARD, &range) < 0)
1000 return errno;
1001@@ -144,9 +144,9 @@ platform_discard_blocks(int fd, uint64_t start, uint64_t len)
1002 #define EFSBADCRC EBADMSG /* Bad CRC detected */
1003
1004 typedef off_t xfs_off_t;
1005-typedef __uint64_t xfs_ino_t;
1006-typedef __uint32_t xfs_dev_t;
1007-typedef __int64_t xfs_daddr_t;
1008+typedef uint64_t xfs_ino_t;
1009+typedef uint32_t xfs_dev_t;
1010+typedef int64_t xfs_daddr_t;
1011 typedef __u32 xfs_nlink_t;
1012
1013 /**
1014diff --git a/include/xfs_arch.h b/include/xfs_arch.h
1015index 12cd43e6..186cadba 100644
1016--- a/include/xfs_arch.h
1017+++ b/include/xfs_arch.h
1018@@ -244,39 +244,39 @@ static inline void be64_add_cpu(__be64 *a, __s64 b)
1019 *a = cpu_to_be64(be64_to_cpu(*a) + b);
1020 }
1021
1022-static inline __uint16_t get_unaligned_be16(void *p)
1023+static inline uint16_t get_unaligned_be16(void *p)
1024 {
1025- __uint8_t *__p = p;
1026+ uint8_t *__p = p;
1027 return __p[0] << 8 | __p[1];
1028 }
1029
1030-static inline __uint32_t get_unaligned_be32(void *p)
1031+static inline uint32_t get_unaligned_be32(void *p)
1032 {
1033- __uint8_t *__p = p;
1034+ uint8_t *__p = p;
1035 return __p[0] << 24 | __p[1] << 16 | __p[2] << 8 | __p[3];
1036 }
1037
1038-static inline __uint64_t get_unaligned_be64(void *p)
1039+static inline uint64_t get_unaligned_be64(void *p)
1040 {
1041- return (__uint64_t)get_unaligned_be32(p) << 32 |
1042+ return (uint64_t)get_unaligned_be32(p) << 32 |
1043 get_unaligned_be32(p + 4);
1044 }
1045
1046-static inline void put_unaligned_be16(__uint16_t val, void *p)
1047+static inline void put_unaligned_be16(uint16_t val, void *p)
1048 {
1049- __uint8_t *__p = p;
1050+ uint8_t *__p = p;
1051 *__p++ = val >> 8;
1052 *__p++ = val;
1053 }
1054
1055-static inline void put_unaligned_be32(__uint32_t val, void *p)
1056+static inline void put_unaligned_be32(uint32_t val, void *p)
1057 {
1058- __uint8_t *__p = p;
1059+ uint8_t *__p = p;
1060 put_unaligned_be16(val >> 16, __p);
1061 put_unaligned_be16(val, __p + 2);
1062 }
1063
1064-static inline void put_unaligned_be64(__uint64_t val, void *p)
1065+static inline void put_unaligned_be64(uint64_t val, void *p)
1066 {
1067 put_unaligned_be32(val >> 32, p);
1068 put_unaligned_be32(val, p + 4);
1069diff --git a/include/xfs_inode.h b/include/xfs_inode.h
1070index fb6b5429..8766024e 100644
1071--- a/include/xfs_inode.h
1072+++ b/include/xfs_inode.h
1073@@ -123,8 +123,8 @@ xfs_get_projid(struct xfs_icdinode *id)
1074 static inline void
1075 xfs_set_projid(struct xfs_icdinode *id, prid_t projid)
1076 {
1077- id->di_projid_hi = (__uint16_t) (projid >> 16);
1078- id->di_projid_lo = (__uint16_t) (projid & 0xffff);
1079+ id->di_projid_hi = (uint16_t) (projid >> 16);
1080+ id->di_projid_lo = (uint16_t) (projid & 0xffff);
1081 }
1082
1083 static inline bool xfs_is_reflink_inode(struct xfs_inode *ip)
1084diff --git a/include/xfs_log_recover.h b/include/xfs_log_recover.h
1085index 7582676b..0d098628 100644
1086--- a/include/xfs_log_recover.h
1087+++ b/include/xfs_log_recover.h
1088@@ -26,7 +26,7 @@
1089 #define XLOG_RHASH_SIZE 16
1090 #define XLOG_RHASH_SHIFT 2
1091 #define XLOG_RHASH(tid) \
1092- ((((__uint32_t)tid)>>XLOG_RHASH_SHIFT) & (XLOG_RHASH_SIZE-1))
1093+ ((((uint32_t)tid)>>XLOG_RHASH_SHIFT) & (XLOG_RHASH_SIZE-1))
1094
1095 #define XLOG_MAX_REGIONS_IN_ITEM (XFS_MAX_BLOCKSIZE / XFS_BLF_CHUNK / 2 + 1)
1096
1097diff --git a/include/xfs_metadump.h b/include/xfs_metadump.h
1098index 7f3039eb..13afb8dd 100644
1099--- a/include/xfs_metadump.h
1100+++ b/include/xfs_metadump.h
1101@@ -24,8 +24,8 @@
1102 typedef struct xfs_metablock {
1103 __be32 mb_magic;
1104 __be16 mb_count;
1105- __uint8_t mb_blocklog;
1106- __uint8_t mb_info;
1107+ uint8_t mb_blocklog;
1108+ uint8_t mb_info;
1109 /* followed by an array of xfs_daddr_t */
1110 } xfs_metablock_t;
1111
1112diff --git a/include/xfs_mount.h b/include/xfs_mount.h
1113index 5ff24ebf..5b323bb1 100644
1114--- a/include/xfs_mount.h
1115+++ b/include/xfs_mount.h
1116@@ -48,12 +48,12 @@ typedef struct xfs_mount {
1117 #define m_dev m_ddev_targp
1118 #define m_logdev m_logdev_targp
1119 #define m_rtdev m_rtdev_targp
1120- __uint8_t m_dircook_elog; /* log d-cookie entry bits */
1121- __uint8_t m_blkbit_log; /* blocklog + NBBY */
1122- __uint8_t m_blkbb_log; /* blocklog - BBSHIFT */
1123- __uint8_t m_sectbb_log; /* sectorlog - BBSHIFT */
1124- __uint8_t m_agno_log; /* log #ag's */
1125- __uint8_t m_agino_log; /* #bits for agino in inum */
1126+ uint8_t m_dircook_elog; /* log d-cookie entry bits */
1127+ uint8_t m_blkbit_log; /* blocklog + NBBY */
1128+ uint8_t m_blkbb_log; /* blocklog - BBSHIFT */
1129+ uint8_t m_sectbb_log; /* sectorlog - BBSHIFT */
1130+ uint8_t m_agno_log; /* log #ag's */
1131+ uint8_t m_agino_log; /* #bits for agino in inum */
1132 uint m_inode_cluster_size;/* min inode buf size */
1133 uint m_blockmask; /* sb_blocksize-1 */
1134 uint m_blockwsize; /* sb_blocksize in words */
1135@@ -88,7 +88,7 @@ typedef struct xfs_mount {
1136 int m_litino; /* size of inode union area */
1137 int m_inoalign_mask;/* mask sb_inoalignmt if used */
1138 struct xfs_trans_resv m_resv; /* precomputed res values */
1139- __uint64_t m_maxicount; /* maximum inode count */
1140+ uint64_t m_maxicount; /* maximum inode count */
1141 int m_dalign; /* stripe unit */
1142 int m_swidth; /* stripe width */
1143 int m_sinoalign; /* stripe unit inode alignmnt */
1144@@ -144,12 +144,12 @@ typedef struct xfs_perag {
1145 char pagi_init; /* this agi's entry is initialized */
1146 char pagf_metadata; /* the agf is preferred to be metadata */
1147 char pagi_inodeok; /* The agi is ok for inodes */
1148- __uint8_t pagf_levels[XFS_BTNUM_AGF];
1149+ uint8_t pagf_levels[XFS_BTNUM_AGF];
1150 /* # of levels in bno & cnt btree */
1151- __uint32_t pagf_flcount; /* count of blocks in freelist */
1152+ uint32_t pagf_flcount; /* count of blocks in freelist */
1153 xfs_extlen_t pagf_freeblks; /* total free blocks */
1154 xfs_extlen_t pagf_longest; /* longest free space */
1155- __uint32_t pagf_btreeblks; /* # of blocks held in AGF btrees */
1156+ uint32_t pagf_btreeblks; /* # of blocks held in AGF btrees */
1157 xfs_agino_t pagi_freecount; /* number of free inodes */
1158 xfs_agino_t pagi_count; /* number of allocated inodes */
1159
1160@@ -169,7 +169,7 @@ typedef struct xfs_perag {
1161 struct xfs_ag_resv pag_agfl_resv;
1162
1163 /* reference count */
1164- __uint8_t pagf_refcount_level;
1165+ uint8_t pagf_refcount_level;
1166 } xfs_perag_t;
1167
1168 static inline struct xfs_ag_resv *
1169diff --git a/libhandle/handle.c b/libhandle/handle.c
1170index 236ed22a..00127b3c 100644
1171--- a/libhandle/handle.c
1172+++ b/libhandle/handle.c
1173@@ -232,7 +232,7 @@ obj_to_handle(
1174 {
1175 char hbuf [MAXHANSIZ];
1176 int ret;
1177- __uint32_t handlen;
1178+ uint32_t handlen;
1179 xfs_fsop_handlereq_t hreq;
1180
1181 if (opcode == XFS_IOC_FD_TO_HANDLE) {
1182diff --git a/libhandle/jdm.c b/libhandle/jdm.c
1183index e52f5d83..821061b4 100644
1184--- a/libhandle/jdm.c
1185+++ b/libhandle/jdm.c
1186@@ -36,7 +36,7 @@ typedef struct filehandle {
1187 fshandle_t fh_fshandle; /* handle of fs containing this inode */
1188 int16_t fh_sz_following; /* bytes in handle after this member */
1189 char fh_pad[FILEHANDLE_SZ_PAD]; /* padding, must be zeroed */
1190- __uint32_t fh_gen; /* generation count */
1191+ uint32_t fh_gen; /* generation count */
1192 xfs_ino_t fh_ino; /* 64 bit ino */
1193 } filehandle_t;
1194
1195diff --git a/libxcmd/topology.c b/libxcmd/topology.c
1196index 8b0276a7..f66dd1bc 100644
1197--- a/libxcmd/topology.c
1198+++ b/libxcmd/topology.c
1199@@ -23,19 +23,19 @@
1200 #endif /* ENABLE_BLKID */
1201 #include "xfs_multidisk.h"
1202
1203-#define TERABYTES(count, blog) ((__uint64_t)(count) << (40 - (blog)))
1204-#define GIGABYTES(count, blog) ((__uint64_t)(count) << (30 - (blog)))
1205-#define MEGABYTES(count, blog) ((__uint64_t)(count) << (20 - (blog)))
1206+#define TERABYTES(count, blog) ((uint64_t)(count) << (40 - (blog)))
1207+#define GIGABYTES(count, blog) ((uint64_t)(count) << (30 - (blog)))
1208+#define MEGABYTES(count, blog) ((uint64_t)(count) << (20 - (blog)))
1209
1210 void
1211 calc_default_ag_geometry(
1212 int blocklog,
1213- __uint64_t dblocks,
1214+ uint64_t dblocks,
1215 int multidisk,
1216- __uint64_t *agsize,
1217- __uint64_t *agcount)
1218+ uint64_t *agsize,
1219+ uint64_t *agcount)
1220 {
1221- __uint64_t blocks = 0;
1222+ uint64_t blocks = 0;
1223 int shift = 0;
1224
1225 /*
1226diff --git a/libxfs/darwin.c b/libxfs/darwin.c
1227index 74507e81..16d2c35c 100644
1228--- a/libxfs/darwin.c
1229+++ b/libxfs/darwin.c
1230@@ -68,7 +68,7 @@ platform_flush_device(int fd, dev_t device)
1231 void
1232 platform_findsizes(char *path, int fd, long long *sz, int *bsz)
1233 {
1234- __uint64_t size;
1235+ uint64_t size;
1236 struct stat st;
1237
1238 if (fstat(fd, &st) < 0) {
1239diff --git a/libxfs/freebsd.c b/libxfs/freebsd.c
1240index 4667d1f5..d7bca142 100644
1241--- a/libxfs/freebsd.c
1242+++ b/libxfs/freebsd.c
1243@@ -109,7 +109,7 @@ void
1244 platform_findsizes(char *path, int fd, long long *sz, int *bsz)
1245 {
1246 struct stat st;
1247- __int64_t size;
1248+ int64_t size;
1249 u_int ssize;
1250
1251 if (fstat(fd, &st) < 0) {
1252diff --git a/libxfs/init.c b/libxfs/init.c
1253index fc14c5e4..0f41a853 100644
1254--- a/libxfs/init.c
1255+++ b/libxfs/init.c
1256@@ -546,7 +546,7 @@ libxfs_initialize_perag(
1257 * the max inode percentage.
1258 */
1259 if (mp->m_maxicount) {
1260- __uint64_t icount;
1261+ uint64_t icount;
1262
1263 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
1264 do_div(icount, 100);
1265diff --git a/libxfs/irix.c b/libxfs/irix.c
1266index 32fcb3e5..0f14aec7 100644
1267--- a/libxfs/irix.c
1268+++ b/libxfs/irix.c
1269@@ -22,7 +22,7 @@
1270
1271 int platform_has_uuid = 0;
1272 extern char *progname;
1273-extern __int64_t findsize(char *);
1274+extern int64_t findsize(char *);
1275
1276 int
1277 platform_check_ismounted(char *name, char *block, struct stat *s, int verbose)
1278diff --git a/libxfs/libxfs_priv.h b/libxfs/libxfs_priv.h
1279index b4f766db..d525b667 100644
1280--- a/libxfs/libxfs_priv.h
1281+++ b/libxfs/libxfs_priv.h
1282@@ -296,8 +296,8 @@ roundup_pow_of_two(uint v)
1283 return 0;
1284 }
1285
1286-static inline __uint64_t
1287-roundup_64(__uint64_t x, __uint32_t y)
1288+static inline uint64_t
1289+roundup_64(uint64_t x, uint32_t y)
1290 {
1291 x += y - 1;
1292 do_div(x, y);
1293diff --git a/libxfs/linux.c b/libxfs/linux.c
1294index 69f04ad9..0bace3eb 100644
1295--- a/libxfs/linux.c
1296+++ b/libxfs/linux.c
1297@@ -163,7 +163,7 @@ void
1298 platform_findsizes(char *path, int fd, long long *sz, int *bsz)
1299 {
1300 struct stat st;
1301- __uint64_t size;
1302+ uint64_t size;
1303 int error;
1304
1305 if (fstat(fd, &st) < 0) {
1306diff --git a/libxfs/logitem.c b/libxfs/logitem.c
1307index 7e93f609..466b4421 100644
1308--- a/libxfs/logitem.c
1309+++ b/libxfs/logitem.c
1310@@ -121,7 +121,7 @@ xfs_buf_item_init(
1311 bip->bli_item.li_mountp = mp;
1312 bip->bli_buf = bp;
1313 bip->bli_format.blf_type = XFS_LI_BUF;
1314- bip->bli_format.blf_blkno = (__int64_t)XFS_BUF_ADDR(bp);
1315+ bip->bli_format.blf_blkno = (int64_t)XFS_BUF_ADDR(bp);
1316 bip->bli_format.blf_len = (unsigned short)BTOBB(XFS_BUF_COUNT(bp));
1317 XFS_BUF_SET_FSPRIVATE(bp, bip);
1318 }
1319diff --git a/libxfs/radix-tree.c b/libxfs/radix-tree.c
1320index eef9c36d..3f0257fe 100644
1321--- a/libxfs/radix-tree.c
1322+++ b/libxfs/radix-tree.c
1323@@ -66,21 +66,21 @@ static unsigned long height_to_maxindex[RADIX_TREE_MAX_PATH];
1324 static inline void tag_set(struct radix_tree_node *node, unsigned int tag,
1325 int offset)
1326 {
1327- *((__uint32_t *)node->tags[tag] + (offset >> 5)) |= (1 << (offset & 31));
1328+ *((uint32_t *)node->tags[tag] + (offset >> 5)) |= (1 << (offset & 31));
1329 }
1330
1331 static inline void tag_clear(struct radix_tree_node *node, unsigned int tag,
1332 int offset)
1333 {
1334- __uint32_t *p = (__uint32_t*)node->tags[tag] + (offset >> 5);
1335- __uint32_t m = 1 << (offset & 31);
1336+ uint32_t *p = (uint32_t*)node->tags[tag] + (offset >> 5);
1337+ uint32_t m = 1 << (offset & 31);
1338 *p &= ~m;
1339 }
1340
1341 static inline int tag_get(struct radix_tree_node *node, unsigned int tag,
1342 int offset)
1343 {
1344- return 1 & (((const __uint32_t *)node->tags[tag])[offset >> 5] >> (offset & 31));
1345+ return 1 & (((const uint32_t *)node->tags[tag])[offset >> 5] >> (offset & 31));
1346 }
1347
1348 /*
1349diff --git a/libxfs/rdwr.c b/libxfs/rdwr.c
1350index 21c42f14..474e5ebc 100644
1351--- a/libxfs/rdwr.c
1352+++ b/libxfs/rdwr.c
1353@@ -118,9 +118,9 @@ static void unmount_record(void *p)
1354 xlog_op_header_t *op = (xlog_op_header_t *)p;
1355 /* the data section must be 32 bit size aligned */
1356 struct {
1357- __uint16_t magic;
1358- __uint16_t pad1;
1359- __uint32_t pad2; /* may as well make it 64 bits */
1360+ uint16_t magic;
1361+ uint16_t pad1;
1362+ uint32_t pad2; /* may as well make it 64 bits */
1363 } magic = { XLOG_UNMOUNT_TYPE, 0, 0 };
1364
1365 memset(p, 0, BBSIZE);
1366diff --git a/libxfs/util.c b/libxfs/util.c
1367index dcfca397..7938e317 100644
1368--- a/libxfs/util.c
1369+++ b/libxfs/util.c
1370@@ -170,8 +170,8 @@ libxfs_trans_ichgtime(
1371 if (flags & XFS_ICHGTIME_CHG)
1372 VFS_I(ip)->i_ctime = tv;
1373 if (flags & XFS_ICHGTIME_CREATE) {
1374- ip->i_d.di_crtime.t_sec = (__int32_t)tv.tv_sec;
1375- ip->i_d.di_crtime.t_nsec = (__int32_t)tv.tv_nsec;
1376+ ip->i_d.di_crtime.t_sec = (int32_t)tv.tv_sec;
1377+ ip->i_d.di_crtime.t_nsec = (int32_t)tv.tv_nsec;
1378 }
1379 }
1380
1381@@ -261,8 +261,8 @@ libxfs_ialloc(
1382 ASSERT(uuid_equal(&ip->i_d.di_uuid, &mp->m_sb.sb_meta_uuid));
1383 VFS_I(ip)->i_version = 1;
1384 ip->i_d.di_flags2 = 0;
1385- ip->i_d.di_crtime.t_sec = (__int32_t)VFS_I(ip)->i_mtime.tv_sec;
1386- ip->i_d.di_crtime.t_nsec = (__int32_t)VFS_I(ip)->i_mtime.tv_nsec;
1387+ ip->i_d.di_crtime.t_sec = (int32_t)VFS_I(ip)->i_mtime.tv_sec;
1388+ ip->i_d.di_crtime.t_nsec = (int32_t)VFS_I(ip)->i_mtime.tv_nsec;
1389 }
1390
1391 flags = XFS_ILOG_CORE;
1392diff --git a/logprint/log_misc.c b/logprint/log_misc.c
1393index 0dfcfd19..2fd01ceb 100644
1394--- a/logprint/log_misc.c
1395+++ b/logprint/log_misc.c
1396@@ -166,12 +166,12 @@ xlog_print_trans_header(char **ptr, int len)
1397 {
1398 xfs_trans_header_t *h;
1399 char *cptr = *ptr;
1400- __uint32_t magic;
1401+ uint32_t magic;
1402 char *magic_c = (char *)&magic;
1403
1404 *ptr += len;
1405
1406- magic=*(__uint32_t*)cptr; /* XXX be32_to_cpu soon */
1407+ magic = *(uint32_t *)cptr; /* XXX be32_to_cpu soon */
1408
1409 if (len >= 4) {
1410 #if __BYTE_ORDER == __LITTLE_ENDIAN
1411@@ -201,7 +201,7 @@ xlog_print_trans_buffer(char **ptr, int len, int *i, int num_ops)
1412 int num, skip;
1413 int super_block = 0;
1414 int bucket, col, buckets;
1415- __int64_t blkno;
1416+ int64_t blkno;
1417 xfs_buf_log_format_t lbuf;
1418 int size, blen, map_size, struct_size;
1419 __be64 x, y;
1420diff --git a/mdrestore/xfs_mdrestore.c b/mdrestore/xfs_mdrestore.c
1421index 9d1b4e80..c49c13aa 100644
1422--- a/mdrestore/xfs_mdrestore.c
1423+++ b/mdrestore/xfs_mdrestore.c
1424@@ -66,7 +66,7 @@ perform_restore(
1425 int mb_count;
1426 xfs_metablock_t tmb;
1427 xfs_sb_t sb;
1428- __int64_t bytes_read;
1429+ int64_t bytes_read;
1430
1431 /*
1432 * read in first blocks (superblock 0), set "inprogress" flag for it,
1433diff --git a/mkfs/proto.c b/mkfs/proto.c
1434index 89cd2379..cf8cc391 100644
1435--- a/mkfs/proto.c
1436+++ b/mkfs/proto.c
1437@@ -667,7 +667,7 @@ rtinit(
1438 mp->m_sb.sb_rbmino = rbmip->i_ino;
1439 rbmip->i_d.di_size = mp->m_sb.sb_rbmblocks * mp->m_sb.sb_blocksize;
1440 rbmip->i_d.di_flags = XFS_DIFLAG_NEWRTBM;
1441- *(__uint64_t *)&VFS_I(rbmip)->i_atime = 0;
1442+ *(uint64_t *)&VFS_I(rbmip)->i_atime = 0;
1443 libxfs_trans_log_inode(tp, rbmip, XFS_ILOG_CORE);
1444 libxfs_log_sb(tp);
1445 mp->m_rbmip = rbmip;
1446diff --git a/mkfs/xfs_mkfs.c b/mkfs/xfs_mkfs.c
1447index b5c3a57e..7bb6408f 100644
1448--- a/mkfs/xfs_mkfs.c
1449+++ b/mkfs/xfs_mkfs.c
1450@@ -705,9 +705,9 @@ struct opt_params mopts = {
1451 },
1452 };
1453
1454-#define TERABYTES(count, blog) ((__uint64_t)(count) << (40 - (blog)))
1455-#define GIGABYTES(count, blog) ((__uint64_t)(count) << (30 - (blog)))
1456-#define MEGABYTES(count, blog) ((__uint64_t)(count) << (20 - (blog)))
1457+#define TERABYTES(count, blog) ((uint64_t)(count) << (40 - (blog)))
1458+#define GIGABYTES(count, blog) ((uint64_t)(count) << (30 - (blog)))
1459+#define MEGABYTES(count, blog) ((uint64_t)(count) << (20 - (blog)))
1460
1461 /*
1462 * Use this macro before we have superblock and mount structure
1463@@ -878,7 +878,7 @@ fixup_log_stripe_unit(
1464 xfs_rfsblock_t *logblocks,
1465 int blocklog)
1466 {
1467- __uint64_t tmp_logblocks;
1468+ uint64_t tmp_logblocks;
1469
1470 /*
1471 * Make sure that the log size is a multiple of the stripe unit
1472@@ -910,7 +910,7 @@ fixup_internal_log_stripe(
1473 xfs_mount_t *mp,
1474 int lsflag,
1475 xfs_fsblock_t logstart,
1476- __uint64_t agsize,
1477+ uint64_t agsize,
1478 int sunit,
1479 xfs_rfsblock_t *logblocks,
1480 int blocklog,
1481@@ -934,7 +934,7 @@ fixup_internal_log_stripe(
1482 }
1483
1484 void
1485-validate_log_size(__uint64_t logblocks, int blocklog, int min_logblocks)
1486+validate_log_size(uint64_t logblocks, int blocklog, int min_logblocks)
1487 {
1488 if (logblocks < min_logblocks) {
1489 fprintf(stderr,
1490@@ -959,7 +959,7 @@ validate_log_size(__uint64_t logblocks, int blocklog, int min_logblocks)
1491 static int
1492 calc_default_imaxpct(
1493 int blocklog,
1494- __uint64_t dblocks)
1495+ uint64_t dblocks)
1496 {
1497 /*
1498 * This returns the % of the disk space that is used for
1499@@ -981,9 +981,9 @@ calc_default_imaxpct(
1500 static void
1501 validate_ag_geometry(
1502 int blocklog,
1503- __uint64_t dblocks,
1504- __uint64_t agsize,
1505- __uint64_t agcount)
1506+ uint64_t dblocks,
1507+ uint64_t agsize,
1508+ uint64_t agcount)
1509 {
1510 if (agsize < XFS_AG_MIN_BLOCKS(blocklog)) {
1511 fprintf(stderr,
1512@@ -1059,7 +1059,7 @@ zero_old_xfs_structures(
1513 {
1514 void *buf;
1515 xfs_sb_t sb;
1516- __uint32_t bsize;
1517+ uint32_t bsize;
1518 int i;
1519 xfs_off_t off;
1520
1521@@ -1112,8 +1112,8 @@ zero_old_xfs_structures(
1522 i != sb.sb_blocklog)
1523 goto done;
1524
1525- if (sb.sb_dblocks > ((__uint64_t)sb.sb_agcount * sb.sb_agblocks) ||
1526- sb.sb_dblocks < ((__uint64_t)(sb.sb_agcount - 1) *
1527+ if (sb.sb_dblocks > ((uint64_t)sb.sb_agcount * sb.sb_agblocks) ||
1528+ sb.sb_dblocks < ((uint64_t)(sb.sb_agcount - 1) *
1529 sb.sb_agblocks + XFS_MIN_AG_BLOCKS))
1530 goto done;
1531
1532@@ -1133,7 +1133,7 @@ done:
1533 }
1534
1535 static void
1536-discard_blocks(dev_t dev, __uint64_t nsectors)
1537+discard_blocks(dev_t dev, uint64_t nsectors)
1538 {
1539 int fd;
1540
1541@@ -1395,11 +1395,11 @@ main(
1542 int argc,
1543 char **argv)
1544 {
1545- __uint64_t agcount;
1546+ uint64_t agcount;
1547 xfs_agf_t *agf;
1548 xfs_agi_t *agi;
1549 xfs_agnumber_t agno;
1550- __uint64_t agsize;
1551+ uint64_t agsize;
1552 xfs_alloc_rec_t *arec;
1553 struct xfs_btree_block *block;
1554 int blflag;
1555@@ -1475,10 +1475,10 @@ main(
1556 char *rtsize;
1557 xfs_sb_t *sbp;
1558 int sectorlog;
1559- __uint64_t sector_mask;
1560+ uint64_t sector_mask;
1561 int slflag;
1562 int ssflag;
1563- __uint64_t tmp_agsize;
1564+ uint64_t tmp_agsize;
1565 uuid_t uuid;
1566 int worst_freelist;
1567 libxfs_init_t xi;
1568@@ -2167,7 +2167,7 @@ _("rmapbt not supported with realtime devices\n"));
1569
1570
1571 if (dsize) {
1572- __uint64_t dbytes;
1573+ uint64_t dbytes;
1574
1575 dbytes = getnum(dsize, &dopts, D_SIZE);
1576 if (dbytes % XFS_MIN_BLOCKSIZE) {
1577@@ -2199,7 +2199,7 @@ _("rmapbt not supported with realtime devices\n"));
1578 }
1579
1580 if (logsize) {
1581- __uint64_t logbytes;
1582+ uint64_t logbytes;
1583
1584 logbytes = getnum(logsize, &lopts, L_SIZE);
1585 if (logbytes % XFS_MIN_BLOCKSIZE) {
1586@@ -2216,7 +2216,7 @@ _("rmapbt not supported with realtime devices\n"));
1587 (long long)(logblocks << blocklog));
1588 }
1589 if (rtsize) {
1590- __uint64_t rtbytes;
1591+ uint64_t rtbytes;
1592
1593 rtbytes = getnum(rtsize, &ropts, R_SIZE);
1594 if (rtbytes % XFS_MIN_BLOCKSIZE) {
1595@@ -2236,7 +2236,7 @@ _("rmapbt not supported with realtime devices\n"));
1596 * If specified, check rt extent size against its constraints.
1597 */
1598 if (rtextsize) {
1599- __uint64_t rtextbytes;
1600+ uint64_t rtextbytes;
1601
1602 rtextbytes = getnum(rtextsize, &ropts, R_EXTSIZE);
1603 if (rtextbytes % blocksize) {
1604@@ -2252,8 +2252,8 @@ _("rmapbt not supported with realtime devices\n"));
1605 * and the underlying volume is striped, then set rtextblocks
1606 * to the stripe width.
1607 */
1608- __uint64_t rswidth;
1609- __uint64_t rtextbytes;
1610+ uint64_t rswidth;
1611+ uint64_t rtextbytes;
1612
1613 if (!norsflag && !xi.risfile && !(!rtsize && xi.disfile))
1614 rswidth = ft.rtswidth;
1615@@ -2335,10 +2335,10 @@ _("rmapbt not supported with realtime devices\n"));
1616 * multiple of the sector size, or 1024, whichever is larger.
1617 */
1618
1619- sector_mask = (__uint64_t)-1 << (MAX(sectorlog, 10) - BBSHIFT);
1620+ sector_mask = (uint64_t)-1 << (MAX(sectorlog, 10) - BBSHIFT);
1621 xi.dsize &= sector_mask;
1622 xi.rtsize &= sector_mask;
1623- xi.logBBsize &= (__uint64_t)-1 << (MAX(lsectorlog, 10) - BBSHIFT);
1624+ xi.logBBsize &= (uint64_t)-1 << (MAX(lsectorlog, 10) - BBSHIFT);
1625
1626
1627 /* don't do discards on print-only runs or on files */
1628@@ -2696,9 +2696,9 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
1629 mp = &mbuf;
1630 sbp = &mp->m_sb;
1631 memset(mp, 0, sizeof(xfs_mount_t));
1632- sbp->sb_blocklog = (__uint8_t)blocklog;
1633- sbp->sb_sectlog = (__uint8_t)sectorlog;
1634- sbp->sb_agblklog = (__uint8_t)libxfs_log2_roundup((unsigned int)agsize);
1635+ sbp->sb_blocklog = (uint8_t)blocklog;
1636+ sbp->sb_sectlog = (uint8_t)sectorlog;
1637+ sbp->sb_agblklog = (uint8_t)libxfs_log2_roundup((unsigned int)agsize);
1638 sbp->sb_agblocks = (xfs_agblock_t)agsize;
1639 mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT;
1640 mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT;
1641@@ -2805,14 +2805,14 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
1642 sbp->sb_agcount = (xfs_agnumber_t)agcount;
1643 sbp->sb_rbmblocks = nbmblocks;
1644 sbp->sb_logblocks = (xfs_extlen_t)logblocks;
1645- sbp->sb_sectsize = (__uint16_t)sectorsize;
1646- sbp->sb_inodesize = (__uint16_t)isize;
1647- sbp->sb_inopblock = (__uint16_t)(blocksize / isize);
1648- sbp->sb_sectlog = (__uint8_t)sectorlog;
1649- sbp->sb_inodelog = (__uint8_t)inodelog;
1650- sbp->sb_inopblog = (__uint8_t)(blocklog - inodelog);
1651+ sbp->sb_sectsize = (uint16_t)sectorsize;
1652+ sbp->sb_inodesize = (uint16_t)isize;
1653+ sbp->sb_inopblock = (uint16_t)(blocksize / isize);
1654+ sbp->sb_sectlog = (uint8_t)sectorlog;
1655+ sbp->sb_inodelog = (uint8_t)inodelog;
1656+ sbp->sb_inopblog = (uint8_t)(blocklog - inodelog);
1657 sbp->sb_rextslog =
1658- (__uint8_t)(rtextents ?
1659+ (uint8_t)(rtextents ?
1660 libxfs_highbit32((unsigned int)rtextents) : 0);
1661 sbp->sb_inprogress = 1; /* mkfs is in progress */
1662 sbp->sb_imax_pct = imaxpct;
1663@@ -2840,8 +2840,8 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
1664 } else
1665 sbp->sb_inoalignmt = 0;
1666 if (lsectorsize != BBSIZE || sectorsize != BBSIZE) {
1667- sbp->sb_logsectlog = (__uint8_t)lsectorlog;
1668- sbp->sb_logsectsize = (__uint16_t)lsectorsize;
1669+ sbp->sb_logsectlog = (uint8_t)lsectorlog;
1670+ sbp->sb_logsectsize = (uint16_t)lsectorsize;
1671 } else {
1672 sbp->sb_logsectlog = 0;
1673 sbp->sb_logsectsize = 0;
1674diff --git a/quota/edit.c b/quota/edit.c
1675index 36b327a5..8418e858 100644
1676--- a/quota/edit.c
1677+++ b/quota/edit.c
1678@@ -115,16 +115,16 @@ warn_help(void)
1679
1680 static void
1681 set_limits(
1682- __uint32_t id,
1683+ uint32_t id,
1684 uint type,
1685 uint mask,
1686 char *dev,
1687- __uint64_t *bsoft,
1688- __uint64_t *bhard,
1689- __uint64_t *isoft,
1690- __uint64_t *ihard,
1691- __uint64_t *rtbsoft,
1692- __uint64_t *rtbhard)
1693+ uint64_t *bsoft,
1694+ uint64_t *bhard,
1695+ uint64_t *isoft,
1696+ uint64_t *ihard,
1697+ uint64_t *rtbsoft,
1698+ uint64_t *rtbhard)
1699 {
1700 fs_disk_quota_t d;
1701
1702@@ -152,12 +152,12 @@ set_user_limits(
1703 char *name,
1704 uint type,
1705 uint mask,
1706- __uint64_t *bsoft,
1707- __uint64_t *bhard,
1708- __uint64_t *isoft,
1709- __uint64_t *ihard,
1710- __uint64_t *rtbsoft,
1711- __uint64_t *rtbhard)
1712+ uint64_t *bsoft,
1713+ uint64_t *bhard,
1714+ uint64_t *isoft,
1715+ uint64_t *ihard,
1716+ uint64_t *rtbsoft,
1717+ uint64_t *rtbhard)
1718 {
1719 uid_t uid = uid_from_string(name);
1720
1721@@ -175,12 +175,12 @@ set_group_limits(
1722 char *name,
1723 uint type,
1724 uint mask,
1725- __uint64_t *bsoft,
1726- __uint64_t *bhard,
1727- __uint64_t *isoft,
1728- __uint64_t *ihard,
1729- __uint64_t *rtbsoft,
1730- __uint64_t *rtbhard)
1731+ uint64_t *bsoft,
1732+ uint64_t *bhard,
1733+ uint64_t *isoft,
1734+ uint64_t *ihard,
1735+ uint64_t *rtbsoft,
1736+ uint64_t *rtbhard)
1737 {
1738 gid_t gid = gid_from_string(name);
1739
1740@@ -198,12 +198,12 @@ set_project_limits(
1741 char *name,
1742 uint type,
1743 uint mask,
1744- __uint64_t *bsoft,
1745- __uint64_t *bhard,
1746- __uint64_t *isoft,
1747- __uint64_t *ihard,
1748- __uint64_t *rtbsoft,
1749- __uint64_t *rtbhard)
1750+ uint64_t *bsoft,
1751+ uint64_t *bhard,
1752+ uint64_t *isoft,
1753+ uint64_t *ihard,
1754+ uint64_t *rtbsoft,
1755+ uint64_t *rtbhard)
1756 {
1757 prid_t prid = prid_from_string(name);
1758
1759@@ -224,7 +224,7 @@ extractb(
1760 int length,
1761 uint blocksize,
1762 uint sectorsize,
1763- __uint64_t *value)
1764+ uint64_t *value)
1765 {
1766 long long v;
1767 char *s = string;
1768@@ -238,7 +238,7 @@ extractb(
1769 progname, s);
1770 return 0;
1771 }
1772- *value = (__uint64_t)v >> 9; /* syscalls use basic blocks */
1773+ *value = (uint64_t)v >> 9; /* syscalls use basic blocks */
1774 if (v > 0 && *value == 0)
1775 fprintf(stderr, _("%s: Warning: `%s' in quota blocks is 0 (unlimited).\n"), progname, s);
1776 return 1;
1777@@ -252,7 +252,7 @@ extracti(
1778 char *string,
1779 const char *prefix,
1780 int length,
1781- __uint64_t *value)
1782+ uint64_t *value)
1783 {
1784 char *sp, *s = string;
1785
1786@@ -270,7 +270,7 @@ limit_f(
1787 char **argv)
1788 {
1789 char *name;
1790- __uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard;
1791+ uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard;
1792 int c, type = 0, mask = 0, flags = 0;
1793 uint bsize, ssize, endoptions;
1794
1795@@ -384,8 +384,8 @@ restore_file(
1796 char *dev = NULL;
1797 uint mask;
1798 int cnt;
1799- __uint32_t id;
1800- __uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard;
1801+ uint32_t id;
1802+ uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard;
1803
1804 while (fgets(buffer, sizeof(buffer), fp) != NULL) {
1805 if (strncmp("fs = ", buffer, 5) == 0) {
1806@@ -546,7 +546,7 @@ timer_f(
1807
1808 static void
1809 set_warnings(
1810- __uint32_t id,
1811+ uint32_t id,
1812 uint type,
1813 uint mask,
1814 char *dev,
1815diff --git a/quota/free.c b/quota/free.c
1816index cee15ee9..1f8378d2 100644
1817--- a/quota/free.c
1818+++ b/quota/free.c
1819@@ -49,20 +49,20 @@ free_help(void)
1820 static int
1821 mount_free_space_data(
1822 struct fs_path *mount,
1823- __uint64_t *bcount,
1824- __uint64_t *bused,
1825- __uint64_t *bfree,
1826- __uint64_t *icount,
1827- __uint64_t *iused,
1828- __uint64_t *ifree,
1829- __uint64_t *rcount,
1830- __uint64_t *rused,
1831- __uint64_t *rfree)
1832+ uint64_t *bcount,
1833+ uint64_t *bused,
1834+ uint64_t *bfree,
1835+ uint64_t *icount,
1836+ uint64_t *iused,
1837+ uint64_t *ifree,
1838+ uint64_t *rcount,
1839+ uint64_t *rused,
1840+ uint64_t *rfree)
1841 {
1842 struct xfs_fsop_counts fscounts;
1843 struct xfs_fsop_geom fsgeo;
1844 struct statfs st;
1845- __uint64_t logsize, count, free;
1846+ uint64_t logsize, count, free;
1847 int fd;
1848
1849 if ((fd = open(mount->fs_dir, O_RDONLY)) < 0) {
1850@@ -132,15 +132,15 @@ mount_free_space_data(
1851 static int
1852 projects_free_space_data(
1853 struct fs_path *path,
1854- __uint64_t *bcount,
1855- __uint64_t *bused,
1856- __uint64_t *bfree,
1857- __uint64_t *icount,
1858- __uint64_t *iused,
1859- __uint64_t *ifree,
1860- __uint64_t *rcount,
1861- __uint64_t *rused,
1862- __uint64_t *rfree)
1863+ uint64_t *bcount,
1864+ uint64_t *bused,
1865+ uint64_t *bfree,
1866+ uint64_t *icount,
1867+ uint64_t *iused,
1868+ uint64_t *ifree,
1869+ uint64_t *rcount,
1870+ uint64_t *rused,
1871+ uint64_t *rfree)
1872 {
1873 fs_quota_stat_t qfs;
1874 fs_disk_quota_t d;
1875@@ -226,9 +226,9 @@ free_space(
1876 fs_path_t *path,
1877 uint flags)
1878 {
1879- __uint64_t bcount, bused, bfree;
1880- __uint64_t icount, iused, ifree;
1881- __uint64_t rcount, rused, rfree;
1882+ uint64_t bcount, bused, bfree;
1883+ uint64_t icount, iused, ifree;
1884+ uint64_t rcount, rused, rfree;
1885 char a[8], s[8], u[8], p[8];
1886 int count;
1887
1888diff --git a/quota/quot.c b/quota/quot.c
1889index ccc154f5..6378fbb7 100644
1890--- a/quota/quot.c
1891+++ b/quota/quot.c
1892@@ -26,17 +26,17 @@
1893
1894 typedef struct du {
1895 struct du *next;
1896- __uint64_t blocks;
1897- __uint64_t blocks30;
1898- __uint64_t blocks60;
1899- __uint64_t blocks90;
1900- __uint64_t nfiles;
1901- __uint32_t id;
1902+ uint64_t blocks;
1903+ uint64_t blocks30;
1904+ uint64_t blocks60;
1905+ uint64_t blocks90;
1906+ uint64_t nfiles;
1907+ uint32_t id;
1908 } du_t;
1909
1910 #define TSIZE 500
1911-static __uint64_t sizes[TSIZE];
1912-static __uint64_t overflow;
1913+static uint64_t sizes[TSIZE];
1914+static uint64_t overflow;
1915
1916 #define NDU 60000
1917 #define DUHASH 8209
1918@@ -84,8 +84,8 @@ quot_bulkstat_add(
1919 {
1920 du_t *dp;
1921 du_t **hp;
1922- __uint64_t size;
1923- __uint32_t i, id;
1924+ uint64_t size;
1925+ uint32_t i, id;
1926
1927 if ((p->bs_mode & S_IFMT) == 0)
1928 return;
1929@@ -203,7 +203,7 @@ qcompare(
1930 return 0;
1931 }
1932
1933-typedef char *(*idtoname_t)(__uint32_t);
1934+typedef char *(*idtoname_t)(uint32_t);
1935
1936 static void
1937 quot_report_mount_any_type(
1938@@ -291,7 +291,7 @@ quot_histogram_mount(
1939 fs_path_t *mount,
1940 uint flags)
1941 {
1942- __uint64_t t = 0;
1943+ uint64_t t = 0;
1944 int i;
1945
1946 fprintf(fp, _("%s (%s):\n"), mount->fs_name, mount->fs_dir);
1947diff --git a/quota/quota.c b/quota/quota.c
1948index d09e239b..479b970e 100644
1949--- a/quota/quota.c
1950+++ b/quota/quota.c
1951@@ -52,7 +52,7 @@ quota_help(void)
1952 static int
1953 quota_mount(
1954 FILE *fp,
1955- __uint32_t id,
1956+ uint32_t id,
1957 char *name,
1958 uint form,
1959 uint type,
1960@@ -181,7 +181,7 @@ quota_mount(
1961 static void
1962 quota(
1963 FILE *fp,
1964- __uint32_t id,
1965+ uint32_t id,
1966 char *name,
1967 uint form,
1968 uint type,
1969diff --git a/quota/quota.h b/quota/quota.h
1970index 4bde3513..9ed28bee 100644
1971--- a/quota/quota.h
1972+++ b/quota/quota.h
1973@@ -53,9 +53,9 @@ enum {
1974 extern char *type_to_string(uint __type);
1975 extern char *form_to_string(uint __form);
1976 extern char *time_to_string(time_t __time, uint __flags);
1977-extern char *bbs_to_string(__uint64_t __v, char *__c, uint __size);
1978-extern char *num_to_string(__uint64_t __v, char *__c, uint __size);
1979-extern char *pct_to_string(__uint64_t __v, __uint64_t __t, char *__c, uint __s);
1980+extern char *bbs_to_string(uint64_t __v, char *__c, uint __size);
1981+extern char *num_to_string(uint64_t __v, char *__c, uint __size);
1982+extern char *pct_to_string(uint64_t __v, uint64_t __t, char *__c, uint __s);
1983
1984 extern FILE *fopen_write_secure(char *__filename);
1985
1986@@ -81,7 +81,7 @@ enum {
1987 * Identifier (uid/gid/prid) cache routines
1988 */
1989 #define NMAX 32
1990-extern char *uid_to_name(__uint32_t __uid);
1991-extern char *gid_to_name(__uint32_t __gid);
1992-extern char *prid_to_name(__uint32_t __prid);
1993+extern char *uid_to_name(uint32_t __uid);
1994+extern char *gid_to_name(uint32_t __gid);
1995+extern char *prid_to_name(uint32_t __prid);
1996 extern bool isdigits_only(const char *);
1997diff --git a/quota/report.c b/quota/report.c
1998index d0509c25..b2ea3bbe 100644
1999--- a/quota/report.c
2000+++ b/quota/report.c
2001@@ -333,9 +333,9 @@ report_header(
2002 static int
2003 report_mount(
2004 FILE *fp,
2005- __uint32_t id,
2006+ uint32_t id,
2007 char *name,
2008- __uint32_t *oid,
2009+ uint32_t *oid,
2010 uint form,
2011 uint type,
2012 fs_path_t *mount,
2013diff --git a/quota/state.c b/quota/state.c
2014index 09dfa705..b08bf50b 100644
2015--- a/quota/state.c
2016+++ b/quota/state.c
2017@@ -135,7 +135,7 @@ static void
2018 state_timelimit(
2019 FILE *fp,
2020 uint form,
2021- __uint32_t timelimit)
2022+ uint32_t timelimit)
2023 {
2024 fprintf(fp, _("%s grace time: %s\n"),
2025 form_to_string(form),
2026diff --git a/quota/util.c b/quota/util.c
2027index cafd45f5..37840a86 100644
2028--- a/quota/util.c
2029+++ b/quota/util.c
2030@@ -94,8 +94,8 @@ round_snprintf(
2031 size_t size,
2032 const char *fmt_round,
2033 const char *fmt_not_round,
2034- __uint64_t value,
2035- __uint64_t divisor)
2036+ uint64_t value,
2037+ uint64_t divisor)
2038 {
2039 double v = (double)value / divisor;
2040
2041@@ -107,23 +107,23 @@ round_snprintf(
2042 }
2043
2044 /* Basic blocks (512) bytes are returned from quotactl */
2045-#define BBS_TO_EXABYTES(bbs) ((__uint64_t)(bbs)>>51)
2046-#define BBS_TO_PETABYTES(bbs) ((__uint64_t)(bbs)>>41)
2047-#define BBS_TO_TERABYTES(bbs) ((__uint64_t)(bbs)>>31)
2048-#define BBS_TO_GIGABYTES(bbs) ((__uint64_t)(bbs)>>21)
2049-#define BBS_TO_MEGABYTES(bbs) ((__uint64_t)(bbs)>>11)
2050-#define BBS_TO_KILOBYTES(bbs) ((__uint64_t)(bbs)>>1)
2051-
2052-#define BBEXABYTE ((__uint64_t)1<<51)
2053-#define BBPETABYTE ((__uint64_t)1<<41)
2054-#define BBTERABYTE ((__uint64_t)1<<31)
2055-#define BBGIGABYTE ((__uint64_t)1<<21)
2056-#define BBMEGABYTE ((__uint64_t)1<<11)
2057-#define BBKILOBYTE ((__uint64_t)1<< 1)
2058+#define BBS_TO_EXABYTES(bbs) ((uint64_t)(bbs)>>51)
2059+#define BBS_TO_PETABYTES(bbs) ((uint64_t)(bbs)>>41)
2060+#define BBS_TO_TERABYTES(bbs) ((uint64_t)(bbs)>>31)
2061+#define BBS_TO_GIGABYTES(bbs) ((uint64_t)(bbs)>>21)
2062+#define BBS_TO_MEGABYTES(bbs) ((uint64_t)(bbs)>>11)
2063+#define BBS_TO_KILOBYTES(bbs) ((uint64_t)(bbs)>>1)
2064+
2065+#define BBEXABYTE ((uint64_t)1<<51)
2066+#define BBPETABYTE ((uint64_t)1<<41)
2067+#define BBTERABYTE ((uint64_t)1<<31)
2068+#define BBGIGABYTE ((uint64_t)1<<21)
2069+#define BBMEGABYTE ((uint64_t)1<<11)
2070+#define BBKILOBYTE ((uint64_t)1<< 1)
2071
2072 char *
2073 bbs_to_string(
2074- __uint64_t v,
2075+ uint64_t v,
2076 char *sp,
2077 uint size)
2078 {
2079@@ -146,17 +146,17 @@ bbs_to_string(
2080 return sp;
2081 }
2082
2083-#define THOUSAND ((__uint64_t)1000)
2084-#define MILLION ((__uint64_t)1000*1000)
2085-#define BILLION ((__uint64_t)1000*1000*1000)
2086-#define TRILLION ((__uint64_t)1000*1000*1000*1000)
2087-#define GAZILLION ((__uint64_t)1000*1000*1000*1000*1000)
2088-#define RIDICULOUS ((__uint64_t)1000*1000*1000*1000*1000*1000)
2089-#define STOPALREADY ((__uint64_t)1000*1000*1000*1000*1000*1000*1000)
2090+#define THOUSAND ((uint64_t)1000)
2091+#define MILLION ((uint64_t)1000*1000)
2092+#define BILLION ((uint64_t)1000*1000*1000)
2093+#define TRILLION ((uint64_t)1000*1000*1000*1000)
2094+#define GAZILLION ((uint64_t)1000*1000*1000*1000*1000)
2095+#define RIDICULOUS ((uint64_t)1000*1000*1000*1000*1000*1000)
2096+#define STOPALREADY ((uint64_t)1000*1000*1000*1000*1000*1000*1000)
2097
2098 char *
2099 num_to_string(
2100- __uint64_t v,
2101+ uint64_t v,
2102 char *sp,
2103 uint size)
2104 {
2105@@ -183,8 +183,8 @@ num_to_string(
2106
2107 char *
2108 pct_to_string(
2109- __uint64_t portion,
2110- __uint64_t whole,
2111+ uint64_t portion,
2112+ uint64_t whole,
2113 char *buf,
2114 uint size)
2115 {
2116@@ -237,7 +237,7 @@ type_to_string(
2117 #define IDMASK (NID-1)
2118
2119 typedef struct {
2120- __uint32_t id;
2121+ uint32_t id;
2122 char name[NMAX+1];
2123 } idcache_t;
2124
2125@@ -250,7 +250,7 @@ static int pentriesleft = NID;
2126
2127 static idcache_t *
2128 getnextpwent(
2129- __uint32_t id,
2130+ uint32_t id,
2131 int byid)
2132 {
2133 struct passwd *pw;
2134@@ -266,7 +266,7 @@ getnextpwent(
2135
2136 static idcache_t *
2137 getnextgrent(
2138- __uint32_t id,
2139+ uint32_t id,
2140 int byid)
2141 {
2142 struct group *gr;
2143@@ -281,7 +281,7 @@ getnextgrent(
2144
2145 static idcache_t *
2146 getnextprent(
2147- __uint32_t id,
2148+ uint32_t id,
2149 int byid)
2150 {
2151 fs_project_t *pr;
2152@@ -296,7 +296,7 @@ getnextprent(
2153
2154 char *
2155 uid_to_name(
2156- __uint32_t id)
2157+ uint32_t id)
2158 {
2159 idcache_t *ncp, *idp;
2160
2161@@ -333,7 +333,7 @@ uid_to_name(
2162
2163 char *
2164 gid_to_name(
2165- __uint32_t id)
2166+ uint32_t id)
2167 {
2168 idcache_t *ncp, *idp;
2169
2170@@ -370,7 +370,7 @@ gid_to_name(
2171
2172 char *
2173 prid_to_name(
2174- __uint32_t id)
2175+ uint32_t id)
2176 {
2177 idcache_t *ncp, *idp;
2178
2179diff --git a/repair/README b/repair/README
2180index 7f168e69..4692463d 100644
2181--- a/repair/README
2182+++ b/repair/README
2183@@ -189,7 +189,7 @@ D - 0) look at usage of XFS_MAKE_IPTR(). It does the right
2184
2185
2186 D - 0) look at references to XFS_INODES_PER_CHUNK. change the
2187- ones that really mean sizeof(__uint64_t)*NBBY to
2188+ ones that really mean sizeof(uint64_t)*NBBY to
2189 something else (like that only defined as a constant
2190 INOS_PER_IREC. this isn't as important since
2191 XFS_INODES_PER_CHUNK will never chang
2192diff --git a/repair/agheader.h b/repair/agheader.h
2193index 6b2974ca..2f7246d2 100644
2194--- a/repair/agheader.h
2195+++ b/repair/agheader.h
2196@@ -20,7 +20,7 @@ typedef struct fs_geometry {
2197 /*
2198 * these types should match the superblock types
2199 */
2200- __uint32_t sb_blocksize; /* blocksize (bytes) */
2201+ uint32_t sb_blocksize; /* blocksize (bytes) */
2202 xfs_rfsblock_t sb_dblocks; /* # data blocks */
2203 xfs_rfsblock_t sb_rblocks; /* # realtime blocks */
2204 xfs_rtblock_t sb_rextents; /* # realtime extents */
2205@@ -30,9 +30,9 @@ typedef struct fs_geometry {
2206 xfs_agnumber_t sb_agcount; /* # of ags */
2207 xfs_extlen_t sb_rbmblocks; /* # of rt bitmap blocks */
2208 xfs_extlen_t sb_logblocks; /* # of log blocks */
2209- __uint16_t sb_sectsize; /* volume sector size (bytes) */
2210- __uint16_t sb_inodesize; /* inode size (bytes) */
2211- __uint8_t sb_imax_pct; /* max % of fs for inode space */
2212+ uint16_t sb_sectsize; /* volume sector size (bytes) */
2213+ uint16_t sb_inodesize; /* inode size (bytes) */
2214+ uint8_t sb_imax_pct; /* max % of fs for inode space */
2215
2216 /*
2217 * these don't have to match the superblock types but are placed
2218@@ -49,10 +49,10 @@ typedef struct fs_geometry {
2219 /*
2220 * fields after this point have to be checked manually in compare_sb()
2221 */
2222- __uint8_t sb_shared_vn; /* shared version number */
2223+ uint8_t sb_shared_vn; /* shared version number */
2224 xfs_extlen_t sb_inoalignmt; /* inode chunk alignment, fsblocks */
2225- __uint32_t sb_unit; /* stripe or raid unit */
2226- __uint32_t sb_width; /* stripe or width unit */
2227+ uint32_t sb_unit; /* stripe or raid unit */
2228+ uint32_t sb_width; /* stripe or width unit */
2229
2230 /*
2231 * these don't have to match, they track superblock properties
2232diff --git a/repair/attr_repair.h b/repair/attr_repair.h
2233index 7010e4ff..294fad44 100644
2234--- a/repair/attr_repair.h
2235+++ b/repair/attr_repair.h
2236@@ -32,10 +32,10 @@
2237 #define ACL_WRITE 02
2238 #define ACL_EXECUTE 01
2239
2240-typedef __uint16_t xfs_acl_perm_t;
2241-typedef __int32_t xfs_acl_type_t;
2242-typedef __int32_t xfs_acl_tag_t;
2243-typedef __int32_t xfs_acl_id_t;
2244+typedef uint16_t xfs_acl_perm_t;
2245+typedef int32_t xfs_acl_type_t;
2246+typedef int32_t xfs_acl_tag_t;
2247+typedef int32_t xfs_acl_id_t;
2248
2249 /*
2250 * "icacl" = in-core ACL. There is no equivalent in the XFS kernel code,
2251@@ -50,7 +50,7 @@ struct xfs_icacl_entry {
2252 };
2253
2254 struct xfs_icacl {
2255- __int32_t acl_cnt;
2256+ int32_t acl_cnt;
2257 struct xfs_icacl_entry acl_entry[0];
2258 };
2259
2260@@ -59,14 +59,14 @@ struct xfs_icacl {
2261 */
2262 #define XFS_MAC_MAX_SETS 250
2263 typedef struct xfs_mac_label {
2264- __uint8_t ml_msen_type; /* MSEN label type */
2265- __uint8_t ml_mint_type; /* MINT label type */
2266- __uint8_t ml_level; /* Hierarchical level */
2267- __uint8_t ml_grade; /* Hierarchical grade */
2268- __uint16_t ml_catcount; /* Category count */
2269- __uint16_t ml_divcount; /* Division count */
2270+ uint8_t ml_msen_type; /* MSEN label type */
2271+ uint8_t ml_mint_type; /* MINT label type */
2272+ uint8_t ml_level; /* Hierarchical level */
2273+ uint8_t ml_grade; /* Hierarchical grade */
2274+ uint16_t ml_catcount; /* Category count */
2275+ uint16_t ml_divcount; /* Division count */
2276 /* Category set, then Division set */
2277- __uint16_t ml_list[XFS_MAC_MAX_SETS];
2278+ uint16_t ml_list[XFS_MAC_MAX_SETS];
2279 } xfs_mac_label_t;
2280
2281 /* MSEN label type names. Choose an upper case ASCII character. */
2282@@ -93,7 +93,7 @@ typedef struct xfs_mac_label {
2283 /*
2284 * Capabilities (IRIX)
2285 */
2286-typedef __uint64_t xfs_cap_value_t;
2287+typedef uint64_t xfs_cap_value_t;
2288
2289 typedef struct xfs_cap_set {
2290 xfs_cap_value_t cap_effective; /* use in capability checks */
2291diff --git a/repair/avl64.c b/repair/avl64.c
2292index 51cd624c..8f4a1211 100644
2293--- a/repair/avl64.c
2294+++ b/repair/avl64.c
2295@@ -70,8 +70,8 @@ avl64_checktree(
2296 avl64node_t *root)
2297 {
2298 avl64node_t *nlast, *nnext, *np;
2299- __uint64_t offset = 0;
2300- __uint64_t end;
2301+ uint64_t offset = 0;
2302+ uint64_t end;
2303
2304 nlast = nnext = root;
2305
2306@@ -583,8 +583,8 @@ attach:
2307 avl64node_t *
2308 avl64_findanyrange(
2309 avl64tree_desc_t *tree,
2310- __uint64_t start,
2311- __uint64_t end,
2312+ uint64_t start,
2313+ uint64_t end,
2314 int checklen)
2315 {
2316 avl64node_t *np = tree->avl_root;
2317@@ -655,7 +655,7 @@ avl64_findanyrange(
2318 avl64node_t *
2319 avl64_findrange(
2320 avl64tree_desc_t *tree,
2321- __uint64_t value)
2322+ uint64_t value)
2323 {
2324 avl64node_t *np = tree->avl_root;
2325
2326@@ -682,10 +682,10 @@ avl64_findrange(
2327 avl64node_t *
2328 avl64_find(
2329 avl64tree_desc_t *tree,
2330- __uint64_t value)
2331+ uint64_t value)
2332 {
2333 avl64node_t *np = tree->avl_root;
2334- __uint64_t nvalue;
2335+ uint64_t nvalue;
2336
2337 while (np) {
2338 nvalue = AVL_START(tree, np);
2339@@ -909,8 +909,8 @@ static
2340 avl64node_t *
2341 avl64_insert_find_growth(
2342 avl64tree_desc_t *tree,
2343- __uint64_t start, /* range start at start, */
2344- __uint64_t end, /* exclusive */
2345+ uint64_t start, /* range start at start, */
2346+ uint64_t end, /* exclusive */
2347 int *growthp) /* OUT */
2348 {
2349 avl64node_t *root = tree->avl_root;
2350@@ -963,7 +963,7 @@ avl64_insert_grow(
2351 int growth)
2352 {
2353 avl64node_t *nnext;
2354- __uint64_t start = AVL_START(tree, newnode);
2355+ uint64_t start = AVL_START(tree, newnode);
2356
2357 if (growth == AVL_BACK) {
2358
2359@@ -1005,8 +1005,8 @@ avl64_insert(
2360 avl64node_t *newnode)
2361 {
2362 avl64node_t *np;
2363- __uint64_t start = AVL_START(tree, newnode);
2364- __uint64_t end = AVL_END(tree, newnode);
2365+ uint64_t start = AVL_START(tree, newnode);
2366+ uint64_t end = AVL_END(tree, newnode);
2367 int growth;
2368
2369 ASSERT(newnode);
2370@@ -1159,16 +1159,16 @@ avl64ops_t avl_debug_ops = {
2371 avl_debug_end,
2372 }
2373
2374-static __uint64_t
2375+static uint64_t
2376 avl64_debug_start(avl64node_t *node)
2377 {
2378- return (__uint64_t)(struct avl_debug_node *)node->avl_start;
2379+ return (uint64_t)(struct avl_debug_node *)node->avl_start;
2380 }
2381
2382-static __uint64_t
2383+static uint64_t
2384 avl64_debug_end(avl64node_t *node)
2385 {
2386- return (__uint64_t)
2387+ return (uint64_t)
2388 ((struct avl_debug_node *)node->avl_start +
2389 (struct avl_debug_node *)node->avl_size);
2390 }
2391@@ -1304,7 +1304,7 @@ main()
2392 avl64node_t *
2393 avl64_findadjacent(
2394 avl64tree_desc_t *tree,
2395- __uint64_t value,
2396+ uint64_t value,
2397 int dir)
2398 {
2399 avl64node_t *np = tree->avl_root;
2400@@ -1378,8 +1378,8 @@ avl64_findadjacent(
2401 void
2402 avl64_findranges(
2403 avl64tree_desc_t *tree,
2404- __uint64_t start,
2405- __uint64_t end,
2406+ uint64_t start,
2407+ uint64_t end,
2408 avl64node_t **startp,
2409 avl64node_t **endp)
2410 {
2411diff --git a/repair/avl64.h b/repair/avl64.h
2412index fd193218..cd079a00 100644
2413--- a/repair/avl64.h
2414+++ b/repair/avl64.h
2415@@ -32,8 +32,8 @@ typedef struct avl64node {
2416 * avl-tree operations
2417 */
2418 typedef struct avl64ops {
2419- __uint64_t (*avl_start)(avl64node_t *);
2420- __uint64_t (*avl_end)(avl64node_t *);
2421+ uint64_t (*avl_start)(avl64node_t *);
2422+ uint64_t (*avl_end)(avl64node_t *);
2423 } avl64ops_t;
2424
2425 /*
2426@@ -89,32 +89,32 @@ avl64_init_tree(
2427 avl64node_t *
2428 avl64_findrange(
2429 avl64tree_desc_t *tree,
2430- __uint64_t value);
2431+ uint64_t value);
2432
2433 avl64node_t *
2434 avl64_find(
2435 avl64tree_desc_t *tree,
2436- __uint64_t value);
2437+ uint64_t value);
2438
2439 avl64node_t *
2440 avl64_findanyrange(
2441 avl64tree_desc_t *tree,
2442- __uint64_t start,
2443- __uint64_t end,
2444+ uint64_t start,
2445+ uint64_t end,
2446 int checklen);
2447
2448
2449 avl64node_t *
2450 avl64_findadjacent(
2451 avl64tree_desc_t *tree,
2452- __uint64_t value,
2453+ uint64_t value,
2454 int dir);
2455
2456 void
2457 avl64_findranges(
2458 avl64tree_desc_t *tree,
2459- __uint64_t start,
2460- __uint64_t end,
2461+ uint64_t start,
2462+ uint64_t end,
2463 avl64node_t **startp,
2464 avl64node_t **endp);
2465
2466diff --git a/repair/dinode.c b/repair/dinode.c
2467index d664f87a..da872178 100644
2468--- a/repair/dinode.c
2469+++ b/repair/dinode.c
2470@@ -746,7 +746,7 @@ _("%s fork in ino %" PRIu64 " claims dup extent, "
2471 case XR_E_FREE1:
2472 do_warn(
2473 _("%s fork in ino %" PRIu64 " claims free block %" PRIu64 "\n"),
2474- forkname, ino, (__uint64_t) b);
2475+ forkname, ino, (uint64_t) b);
2476 /* fall through ... */
2477 case XR_E_INUSE1: /* seen by rmap */
2478 case XR_E_UNKNOWN:
2479@@ -923,7 +923,7 @@ process_btinode(
2480 int type,
2481 int *dirty,
2482 xfs_rfsblock_t *tot,
2483- __uint64_t *nex,
2484+ uint64_t *nex,
2485 blkmap_t **blkmapp,
2486 int whichfork,
2487 int check_dups)
2488@@ -939,7 +939,7 @@ process_btinode(
2489 int level;
2490 int numrecs;
2491 bmap_cursor_t cursor;
2492- __uint64_t magic;
2493+ uint64_t magic;
2494
2495 dib = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork);
2496 lino = XFS_AGINO_TO_INO(mp, agno, ino);
2497@@ -1098,7 +1098,7 @@ process_exinode(
2498 int type,
2499 int *dirty,
2500 xfs_rfsblock_t *tot,
2501- __uint64_t *nex,
2502+ uint64_t *nex,
2503 blkmap_t **blkmapp,
2504 int whichfork,
2505 int check_dups)
2506@@ -1200,14 +1200,14 @@ process_symlink_extlist(xfs_mount_t *mp, xfs_ino_t lino, xfs_dinode_t *dino)
2507 do_warn(
2508 _("mismatch between format (%d) and size (%" PRId64 ") in symlink ino %" PRIu64 "\n"),
2509 dino->di_format,
2510- (__int64_t)be64_to_cpu(dino->di_size), lino);
2511+ (int64_t)be64_to_cpu(dino->di_size), lino);
2512 return 1;
2513 }
2514 if (dino->di_format == XFS_DINODE_FMT_LOCAL) {
2515 do_warn(
2516 _("mismatch between format (%d) and size (%" PRId64 ") in symlink inode %" PRIu64 "\n"),
2517 dino->di_format,
2518- (__int64_t)be64_to_cpu(dino->di_size), lino);
2519+ (int64_t)be64_to_cpu(dino->di_size), lino);
2520 return 1;
2521 }
2522
2523@@ -1454,22 +1454,22 @@ _("inode %" PRIu64 " has bad inode type (IFMNT)\n"), lino);
2524 case XR_INO_CHRDEV:
2525 do_warn(
2526 _("size of character device inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino,
2527- (__int64_t)be64_to_cpu(dino->di_size));
2528+ (int64_t)be64_to_cpu(dino->di_size));
2529 break;
2530 case XR_INO_BLKDEV:
2531 do_warn(
2532 _("size of block device inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino,
2533- (__int64_t)be64_to_cpu(dino->di_size));
2534+ (int64_t)be64_to_cpu(dino->di_size));
2535 break;
2536 case XR_INO_SOCK:
2537 do_warn(
2538 _("size of socket inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino,
2539- (__int64_t)be64_to_cpu(dino->di_size));
2540+ (int64_t)be64_to_cpu(dino->di_size));
2541 break;
2542 case XR_INO_FIFO:
2543 do_warn(
2544 _("size of fifo inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino,
2545- (__int64_t)be64_to_cpu(dino->di_size));
2546+ (int64_t)be64_to_cpu(dino->di_size));
2547 break;
2548 default:
2549 do_warn(_("Internal error - process_misc_ino_types, "
2550@@ -1743,12 +1743,12 @@ _("found inode %" PRIu64 " claiming to be a real-time file\n"), lino);
2551 break;
2552
2553 case XR_INO_RTBITMAP:
2554- if (size != (__int64_t)mp->m_sb.sb_rbmblocks *
2555+ if (size != (int64_t)mp->m_sb.sb_rbmblocks *
2556 mp->m_sb.sb_blocksize) {
2557 do_warn(
2558 _("realtime bitmap inode %" PRIu64 " has bad size %" PRId64 " (should be %" PRIu64 ")\n"),
2559 lino, size,
2560- (__int64_t) mp->m_sb.sb_rbmblocks *
2561+ (int64_t) mp->m_sb.sb_rbmblocks *
2562 mp->m_sb.sb_blocksize);
2563 return 1;
2564 }
2565@@ -1817,8 +1817,8 @@ static int
2566 process_inode_blocks_and_extents(
2567 xfs_dinode_t *dino,
2568 xfs_rfsblock_t nblocks,
2569- __uint64_t nextents,
2570- __uint64_t anextents,
2571+ uint64_t nextents,
2572+ uint64_t anextents,
2573 xfs_ino_t lino,
2574 int *dirty)
2575 {
2576@@ -1908,7 +1908,7 @@ process_inode_data_fork(
2577 int type,
2578 int *dirty,
2579 xfs_rfsblock_t *totblocks,
2580- __uint64_t *nextents,
2581+ uint64_t *nextents,
2582 blkmap_t **dblkmap,
2583 int check_dups)
2584 {
2585@@ -2017,7 +2017,7 @@ process_inode_attr_fork(
2586 int type,
2587 int *dirty,
2588 xfs_rfsblock_t *atotblocks,
2589- __uint64_t *anextents,
2590+ uint64_t *anextents,
2591 int check_dups,
2592 int extra_attr_check,
2593 int *retval)
2594@@ -2228,8 +2228,8 @@ process_dinode_int(xfs_mount_t *mp,
2595 int di_mode;
2596 int type;
2597 int retval = 0;
2598- __uint64_t nextents;
2599- __uint64_t anextents;
2600+ uint64_t nextents;
2601+ uint64_t anextents;
2602 xfs_ino_t lino;
2603 const int is_free = 0;
2604 const int is_used = 1;
2605@@ -2346,7 +2346,7 @@ _("inode identifier %llu mismatch on inode %" PRIu64 "\n"),
2606 if (!uncertain)
2607 do_warn(
2608 _("bad (negative) size %" PRId64 " on inode %" PRIu64 "\n"),
2609- (__int64_t)be64_to_cpu(dino->di_size),
2610+ (int64_t)be64_to_cpu(dino->di_size),
2611 lino);
2612 if (verify_mode)
2613 return 1;
2614diff --git a/repair/dinode.h b/repair/dinode.h
2615index 61d07363..39d6a72f 100644
2616--- a/repair/dinode.h
2617+++ b/repair/dinode.h
2618@@ -46,8 +46,8 @@ process_bmbt_reclist(xfs_mount_t *mp,
2619 xfs_ino_t ino,
2620 xfs_rfsblock_t *tot,
2621 struct blkmap **blkmapp,
2622- __uint64_t *first_key,
2623- __uint64_t *last_key,
2624+ uint64_t *first_key,
2625+ uint64_t *last_key,
2626 int whichfork);
2627
2628 int
2629diff --git a/repair/dir2.c b/repair/dir2.c
2630index e6415e49..73dff902 100644
2631--- a/repair/dir2.c
2632+++ b/repair/dir2.c
2633@@ -160,7 +160,7 @@ process_sf_dir2(
2634 int bad_sfnamelen;
2635 int i;
2636 int i8;
2637- __int64_t ino_dir_size;
2638+ int64_t ino_dir_size;
2639 int ino_off;
2640 ino_tree_node_t *irec_p;
2641 int junkit;
2642diff --git a/repair/globals.h b/repair/globals.h
2643index 4085ccc4..c7bbe6f1 100644
2644--- a/repair/globals.h
2645+++ b/repair/globals.h
2646@@ -141,7 +141,7 @@ EXTERN int inodes_per_cluster;
2647 EXTERN unsigned int glob_agcount;
2648 EXTERN int chunks_pblock; /* # of 64-ino chunks per allocation */
2649 EXTERN int max_symlink_blocks;
2650-EXTERN __int64_t fs_max_file_offset;
2651+EXTERN int64_t fs_max_file_offset;
2652
2653 /* realtime info */
2654
2655@@ -161,24 +161,24 @@ EXTERN int full_ino_ex_data;/*
2656
2657 /* superblock counters */
2658
2659-EXTERN __uint64_t sb_icount; /* allocated (made) inodes */
2660-EXTERN __uint64_t sb_ifree; /* free inodes */
2661-EXTERN __uint64_t sb_fdblocks; /* free data blocks */
2662-EXTERN __uint64_t sb_frextents; /* free realtime extents */
2663+EXTERN uint64_t sb_icount; /* allocated (made) inodes */
2664+EXTERN uint64_t sb_ifree; /* free inodes */
2665+EXTERN uint64_t sb_fdblocks; /* free data blocks */
2666+EXTERN uint64_t sb_frextents; /* free realtime extents */
2667
2668 /* superblock geometry info */
2669
2670 EXTERN xfs_extlen_t sb_inoalignmt;
2671-EXTERN __uint32_t sb_unit;
2672-EXTERN __uint32_t sb_width;
2673+EXTERN uint32_t sb_unit;
2674+EXTERN uint32_t sb_width;
2675
2676 struct aglock {
2677 pthread_mutex_t lock __attribute__((__aligned__(64)));
2678 };
2679 EXTERN struct aglock *ag_locks;
2680
2681-EXTERN int report_interval;
2682-EXTERN __uint64_t *prog_rpt_done;
2683+EXTERN int report_interval;
2684+EXTERN uint64_t *prog_rpt_done;
2685
2686 EXTERN int ag_stride;
2687 EXTERN int thread_count;
2688diff --git a/repair/incore.c b/repair/incore.c
2689index cb573165..a9191ae2 100644
2690--- a/repair/incore.c
2691+++ b/repair/incore.c
2692@@ -179,7 +179,7 @@ get_bmap_ext(
2693 static uint64_t *rt_bmap;
2694 static size_t rt_bmap_size;
2695
2696-/* block records fit into __uint64_t's units */
2697+/* block records fit into uint64_t's units */
2698 #define XR_BB_UNIT 64 /* number of bits/unit */
2699 #define XR_BB 4 /* bits per block record */
2700 #define XR_BB_NUM (XR_BB_UNIT/XR_BB) /* number of records per unit */
2701@@ -203,8 +203,8 @@ set_rtbmap(
2702 {
2703 *(rt_bmap + bno / XR_BB_NUM) =
2704 ((*(rt_bmap + bno / XR_BB_NUM) &
2705- (~((__uint64_t) XR_BB_MASK << ((bno % XR_BB_NUM) * XR_BB)))) |
2706- (((__uint64_t) state) << ((bno % XR_BB_NUM) * XR_BB)));
2707+ (~((uint64_t) XR_BB_MASK << ((bno % XR_BB_NUM) * XR_BB)))) |
2708+ (((uint64_t) state) << ((bno % XR_BB_NUM) * XR_BB)));
2709 }
2710
2711 static void
2712@@ -222,9 +222,9 @@ init_rt_bmap(
2713 return;
2714
2715 rt_bmap_size = roundup(mp->m_sb.sb_rextents / (NBBY / XR_BB),
2716- sizeof(__uint64_t));
2717+ sizeof(uint64_t));
2718
2719- rt_bmap = memalign(sizeof(__uint64_t), rt_bmap_size);
2720+ rt_bmap = memalign(sizeof(uint64_t), rt_bmap_size);
2721 if (!rt_bmap) {
2722 do_error(
2723 _("couldn't allocate realtime block map, size = %" PRIu64 "\n"),
2724diff --git a/repair/incore.h b/repair/incore.h
2725index c23a3a3c..fd66084f 100644
2726--- a/repair/incore.h
2727+++ b/repair/incore.h
2728@@ -257,7 +257,7 @@ typedef xfs_ino_t parent_entry_t;
2729 struct nlink_ops;
2730
2731 typedef struct parent_list {
2732- __uint64_t pmask;
2733+ uint64_t pmask;
2734 parent_entry_t *pentries;
2735 #ifdef DEBUG
2736 short cnt;
2737@@ -265,14 +265,14 @@ typedef struct parent_list {
2738 } parent_list_t;
2739
2740 union ino_nlink {
2741- __uint8_t *un8;
2742- __uint16_t *un16;
2743- __uint32_t *un32;
2744+ uint8_t *un8;
2745+ uint16_t *un16;
2746+ uint32_t *un32;
2747 };
2748
2749 typedef struct ino_ex_data {
2750- __uint64_t ino_reached; /* bit == 1 if reached */
2751- __uint64_t ino_processed; /* reference checked bit mask */
2752+ uint64_t ino_reached; /* bit == 1 if reached */
2753+ uint64_t ino_processed; /* reference checked bit mask */
2754 parent_list_t *parents;
2755 union ino_nlink counted_nlinks;/* counted nlinks in P6 */
2756 } ino_ex_data_t;
2757@@ -281,22 +281,22 @@ typedef struct ino_tree_node {
2758 avlnode_t avl_node;
2759 xfs_agino_t ino_startnum; /* starting inode # */
2760 xfs_inofree_t ir_free; /* inode free bit mask */
2761- __uint64_t ir_sparse; /* sparse inode bitmask */
2762- __uint64_t ino_confirmed; /* confirmed bitmask */
2763- __uint64_t ino_isa_dir; /* bit == 1 if a directory */
2764- __uint64_t ino_was_rl; /* bit == 1 if reflink flag set */
2765- __uint64_t ino_is_rl; /* bit == 1 if reflink flag should be set */
2766- __uint8_t nlink_size;
2767+ uint64_t ir_sparse; /* sparse inode bitmask */
2768+ uint64_t ino_confirmed; /* confirmed bitmask */
2769+ uint64_t ino_isa_dir; /* bit == 1 if a directory */
2770+ uint64_t ino_was_rl; /* bit == 1 if reflink flag set */
2771+ uint64_t ino_is_rl; /* bit == 1 if reflink flag should be set */
2772+ uint8_t nlink_size;
2773 union ino_nlink disk_nlinks; /* on-disk nlinks, set in P3 */
2774 union {
2775 ino_ex_data_t *ex_data; /* phases 6,7 */
2776 parent_list_t *plist; /* phases 2-5 */
2777 } ino_un;
2778- __uint8_t *ftypes; /* phases 3,6 */
2779+ uint8_t *ftypes; /* phases 3,6 */
2780 } ino_tree_node_t;
2781
2782-#define INOS_PER_IREC (sizeof(__uint64_t) * NBBY)
2783-#define IREC_MASK(i) ((__uint64_t)1 << (i))
2784+#define INOS_PER_IREC (sizeof(uint64_t) * NBBY)
2785+#define IREC_MASK(i) ((uint64_t)1 << (i))
2786
2787 void add_ino_ex_data(xfs_mount_t *mp);
2788
2789@@ -543,10 +543,10 @@ static inline int inode_is_rl(struct ino_tree_node *irec, int offset)
2790 */
2791 void add_inode_ref(struct ino_tree_node *irec, int offset);
2792 void drop_inode_ref(struct ino_tree_node *irec, int offset);
2793-__uint32_t num_inode_references(struct ino_tree_node *irec, int offset);
2794+uint32_t num_inode_references(struct ino_tree_node *irec, int offset);
2795
2796-void set_inode_disk_nlinks(struct ino_tree_node *irec, int offset, __uint32_t nlinks);
2797-__uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int offset);
2798+void set_inode_disk_nlinks(struct ino_tree_node *irec, int offset, uint32_t nlinks);
2799+uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int offset);
2800
2801 static inline int is_inode_reached(struct ino_tree_node *irec, int offset)
2802 {
2803@@ -567,13 +567,13 @@ static inline void add_inode_reached(struct ino_tree_node *irec, int offset)
2804 static inline void
2805 set_inode_ftype(struct ino_tree_node *irec,
2806 int ino_offset,
2807- __uint8_t ftype)
2808+ uint8_t ftype)
2809 {
2810 if (irec->ftypes)
2811 irec->ftypes[ino_offset] = ftype;
2812 }
2813
2814-static inline __uint8_t
2815+static inline uint8_t
2816 get_inode_ftype(
2817 struct ino_tree_node *irec,
2818 int ino_offset)
2819@@ -606,11 +606,11 @@ typedef struct bm_level_state {
2820 xfs_fsblock_t fsbno;
2821 xfs_fsblock_t left_fsbno;
2822 xfs_fsblock_t right_fsbno;
2823- __uint64_t first_key;
2824- __uint64_t last_key;
2825+ uint64_t first_key;
2826+ uint64_t last_key;
2827 /*
2828 int level;
2829- __uint64_t prev_last_key;
2830+ uint64_t prev_last_key;
2831 xfs_buf_t *bp;
2832 xfs_bmbt_block_t *block;
2833 */
2834diff --git a/repair/incore_ext.c b/repair/incore_ext.c
2835index 7e6786c5..0a8138a9 100644
2836--- a/repair/incore_ext.c
2837+++ b/repair/incore_ext.c
2838@@ -721,13 +721,13 @@ search_rt_dup_extent(xfs_mount_t *mp, xfs_rtblock_t bno)
2839 return(ret);
2840 }
2841
2842-static __uint64_t
2843+static uint64_t
2844 avl64_rt_ext_start(avl64node_t *node)
2845 {
2846 return(((rt_extent_tree_node_t *) node)->rt_startblock);
2847 }
2848
2849-static __uint64_t
2850+static uint64_t
2851 avl64_ext_end(avl64node_t *node)
2852 {
2853 return(((rt_extent_tree_node_t *) node)->rt_startblock +
2854@@ -834,7 +834,7 @@ count_extents(xfs_agnumber_t agno, avltree_desc_t *tree, int whichtree)
2855 int
2856 count_bno_extents_blocks(xfs_agnumber_t agno, uint *numblocks)
2857 {
2858- __uint64_t nblocks;
2859+ uint64_t nblocks;
2860 extent_tree_node_t *node;
2861 int i = 0;
2862
2863diff --git a/repair/incore_ino.c b/repair/incore_ino.c
2864index 2ec17657..3b6b44d4 100644
2865--- a/repair/incore_ino.c
2866+++ b/repair/incore_ino.c
2867@@ -38,7 +38,7 @@ static avltree_desc_t **inode_uncertain_tree_ptrs;
2868 /* memory optimised nlink counting for all inodes */
2869
2870 static void *
2871-alloc_nlink_array(__uint8_t nlink_size)
2872+alloc_nlink_array(uint8_t nlink_size)
2873 {
2874 void *ptr;
2875
2876@@ -51,10 +51,10 @@ alloc_nlink_array(__uint8_t nlink_size)
2877 static void
2878 nlink_grow_8_to_16(ino_tree_node_t *irec)
2879 {
2880- __uint16_t *new_nlinks;
2881+ uint16_t *new_nlinks;
2882 int i;
2883
2884- irec->nlink_size = sizeof(__uint16_t);
2885+ irec->nlink_size = sizeof(uint16_t);
2886
2887 new_nlinks = alloc_nlink_array(irec->nlink_size);
2888 for (i = 0; i < XFS_INODES_PER_CHUNK; i++)
2889@@ -76,10 +76,10 @@ nlink_grow_8_to_16(ino_tree_node_t *irec)
2890 static void
2891 nlink_grow_16_to_32(ino_tree_node_t *irec)
2892 {
2893- __uint32_t *new_nlinks;
2894+ uint32_t *new_nlinks;
2895 int i;
2896
2897- irec->nlink_size = sizeof(__uint32_t);
2898+ irec->nlink_size = sizeof(uint32_t);
2899
2900 new_nlinks = alloc_nlink_array(irec->nlink_size);
2901 for (i = 0; i < XFS_INODES_PER_CHUNK; i++)
2902@@ -104,21 +104,21 @@ void add_inode_ref(struct ino_tree_node *irec, int ino_offset)
2903 ASSERT(irec->ino_un.ex_data != NULL);
2904
2905 switch (irec->nlink_size) {
2906- case sizeof(__uint8_t):
2907+ case sizeof(uint8_t):
2908 if (irec->ino_un.ex_data->counted_nlinks.un8[ino_offset] < 0xff) {
2909 irec->ino_un.ex_data->counted_nlinks.un8[ino_offset]++;
2910 break;
2911 }
2912 nlink_grow_8_to_16(irec);
2913 /*FALLTHRU*/
2914- case sizeof(__uint16_t):
2915+ case sizeof(uint16_t):
2916 if (irec->ino_un.ex_data->counted_nlinks.un16[ino_offset] < 0xffff) {
2917 irec->ino_un.ex_data->counted_nlinks.un16[ino_offset]++;
2918 break;
2919 }
2920 nlink_grow_16_to_32(irec);
2921 /*FALLTHRU*/
2922- case sizeof(__uint32_t):
2923+ case sizeof(uint32_t):
2924 irec->ino_un.ex_data->counted_nlinks.un32[ino_offset]++;
2925 break;
2926 default:
2927@@ -128,20 +128,20 @@ void add_inode_ref(struct ino_tree_node *irec, int ino_offset)
2928
2929 void drop_inode_ref(struct ino_tree_node *irec, int ino_offset)
2930 {
2931- __uint32_t refs = 0;
2932+ uint32_t refs = 0;
2933
2934 ASSERT(irec->ino_un.ex_data != NULL);
2935
2936 switch (irec->nlink_size) {
2937- case sizeof(__uint8_t):
2938+ case sizeof(uint8_t):
2939 ASSERT(irec->ino_un.ex_data->counted_nlinks.un8[ino_offset] > 0);
2940 refs = --irec->ino_un.ex_data->counted_nlinks.un8[ino_offset];
2941 break;
2942- case sizeof(__uint16_t):
2943+ case sizeof(uint16_t):
2944 ASSERT(irec->ino_un.ex_data->counted_nlinks.un16[ino_offset] > 0);
2945 refs = --irec->ino_un.ex_data->counted_nlinks.un16[ino_offset];
2946 break;
2947- case sizeof(__uint32_t):
2948+ case sizeof(uint32_t):
2949 ASSERT(irec->ino_un.ex_data->counted_nlinks.un32[ino_offset] > 0);
2950 refs = --irec->ino_un.ex_data->counted_nlinks.un32[ino_offset];
2951 break;
2952@@ -153,16 +153,16 @@ void drop_inode_ref(struct ino_tree_node *irec, int ino_offset)
2953 irec->ino_un.ex_data->ino_reached &= ~IREC_MASK(ino_offset);
2954 }
2955
2956-__uint32_t num_inode_references(struct ino_tree_node *irec, int ino_offset)
2957+uint32_t num_inode_references(struct ino_tree_node *irec, int ino_offset)
2958 {
2959 ASSERT(irec->ino_un.ex_data != NULL);
2960
2961 switch (irec->nlink_size) {
2962- case sizeof(__uint8_t):
2963+ case sizeof(uint8_t):
2964 return irec->ino_un.ex_data->counted_nlinks.un8[ino_offset];
2965- case sizeof(__uint16_t):
2966+ case sizeof(uint16_t):
2967 return irec->ino_un.ex_data->counted_nlinks.un16[ino_offset];
2968- case sizeof(__uint32_t):
2969+ case sizeof(uint32_t):
2970 return irec->ino_un.ex_data->counted_nlinks.un32[ino_offset];
2971 default:
2972 ASSERT(0);
2973@@ -171,24 +171,24 @@ __uint32_t num_inode_references(struct ino_tree_node *irec, int ino_offset)
2974 }
2975
2976 void set_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset,
2977- __uint32_t nlinks)
2978+ uint32_t nlinks)
2979 {
2980 switch (irec->nlink_size) {
2981- case sizeof(__uint8_t):
2982+ case sizeof(uint8_t):
2983 if (nlinks < 0xff) {
2984 irec->disk_nlinks.un8[ino_offset] = nlinks;
2985 break;
2986 }
2987 nlink_grow_8_to_16(irec);
2988 /*FALLTHRU*/
2989- case sizeof(__uint16_t):
2990+ case sizeof(uint16_t):
2991 if (nlinks < 0xffff) {
2992 irec->disk_nlinks.un16[ino_offset] = nlinks;
2993 break;
2994 }
2995 nlink_grow_16_to_32(irec);
2996 /*FALLTHRU*/
2997- case sizeof(__uint32_t):
2998+ case sizeof(uint32_t):
2999 irec->disk_nlinks.un32[ino_offset] = nlinks;
3000 break;
3001 default:
3002@@ -196,14 +196,14 @@ void set_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset,
3003 }
3004 }
3005
3006-__uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset)
3007+uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset)
3008 {
3009 switch (irec->nlink_size) {
3010- case sizeof(__uint8_t):
3011+ case sizeof(uint8_t):
3012 return irec->disk_nlinks.un8[ino_offset];
3013- case sizeof(__uint16_t):
3014+ case sizeof(uint16_t):
3015 return irec->disk_nlinks.un16[ino_offset];
3016- case sizeof(__uint32_t):
3017+ case sizeof(uint32_t):
3018 return irec->disk_nlinks.un32[ino_offset];
3019 default:
3020 ASSERT(0);
3021@@ -211,11 +211,11 @@ __uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset)
3022 return 0;
3023 }
3024
3025-static __uint8_t *
3026+static uint8_t *
3027 alloc_ftypes_array(
3028 struct xfs_mount *mp)
3029 {
3030- __uint8_t *ptr;
3031+ uint8_t *ptr;
3032
3033 if (!xfs_sb_version_hasftype(&mp->m_sb))
3034 return NULL;
3035@@ -262,23 +262,23 @@ alloc_ino_node(
3036 irec->ir_free = (xfs_inofree_t) - 1;
3037 irec->ir_sparse = 0;
3038 irec->ino_un.ex_data = NULL;
3039- irec->nlink_size = sizeof(__uint8_t);
3040+ irec->nlink_size = sizeof(uint8_t);
3041 irec->disk_nlinks.un8 = alloc_nlink_array(irec->nlink_size);
3042 irec->ftypes = alloc_ftypes_array(mp);
3043 return irec;
3044 }
3045
3046 static void
3047-free_nlink_array(union ino_nlink nlinks, __uint8_t nlink_size)
3048+free_nlink_array(union ino_nlink nlinks, uint8_t nlink_size)
3049 {
3050 switch (nlink_size) {
3051- case sizeof(__uint8_t):
3052+ case sizeof(uint8_t):
3053 free(nlinks.un8);
3054 break;
3055- case sizeof(__uint16_t):
3056+ case sizeof(uint16_t):
3057 free(nlinks.un16);
3058 break;
3059- case sizeof(__uint32_t):
3060+ case sizeof(uint32_t):
3061 free(nlinks.un32);
3062 break;
3063 default:
3064@@ -609,7 +609,7 @@ set_inode_parent(
3065 int i;
3066 int cnt;
3067 int target;
3068- __uint64_t bitmask;
3069+ uint64_t bitmask;
3070 parent_entry_t *tmp;
3071
3072 if (full_ino_ex_data)
3073@@ -699,7 +699,7 @@ set_inode_parent(
3074 xfs_ino_t
3075 get_inode_parent(ino_tree_node_t *irec, int offset)
3076 {
3077- __uint64_t bitmask;
3078+ uint64_t bitmask;
3079 parent_list_t *ptbl;
3080 int i;
3081 int target;
3082@@ -740,15 +740,15 @@ alloc_ex_data(ino_tree_node_t *irec)
3083 irec->ino_un.ex_data->parents = ptbl;
3084
3085 switch (irec->nlink_size) {
3086- case sizeof(__uint8_t):
3087+ case sizeof(uint8_t):
3088 irec->ino_un.ex_data->counted_nlinks.un8 =
3089 alloc_nlink_array(irec->nlink_size);
3090 break;
3091- case sizeof(__uint16_t):
3092+ case sizeof(uint16_t):
3093 irec->ino_un.ex_data->counted_nlinks.un16 =
3094 alloc_nlink_array(irec->nlink_size);
3095 break;
3096- case sizeof(__uint32_t):
3097+ case sizeof(uint32_t):
3098 irec->ino_un.ex_data->counted_nlinks.un32 =
3099 alloc_nlink_array(irec->nlink_size);
3100 break;
3101diff --git a/repair/phase2.c b/repair/phase2.c
3102index c21778b8..0085732b 100644
3103--- a/repair/phase2.c
3104+++ b/repair/phase2.c
3105@@ -179,7 +179,7 @@ phase2(
3106
3107 bad_ino_btree = 0;
3108
3109- set_progress_msg(PROG_FMT_SCAN_AG, (__uint64_t) glob_agcount);
3110+ set_progress_msg(PROG_FMT_SCAN_AG, (uint64_t) glob_agcount);
3111
3112 scan_ags(mp, scan_threads);
3113
3114diff --git a/repair/phase3.c b/repair/phase3.c
3115index 0890a27d..17b1c28d 100644
3116--- a/repair/phase3.c
3117+++ b/repair/phase3.c
3118@@ -122,7 +122,7 @@ phase3(
3119 else
3120 do_log(_(" - scan (but don't clear) agi unlinked lists...\n"));
3121
3122- set_progress_msg(PROG_FMT_AGI_UNLINKED, (__uint64_t) glob_agcount);
3123+ set_progress_msg(PROG_FMT_AGI_UNLINKED, (uint64_t) glob_agcount);
3124
3125 /* first clear the agi unlinked AGI list */
3126 if (!no_modify) {
3127@@ -142,7 +142,7 @@ phase3(
3128 do_log(_(
3129 " - process known inodes and perform inode discovery...\n"));
3130
3131- set_progress_msg(PROG_FMT_PROCESS_INO, (__uint64_t) mp->m_sb.sb_icount);
3132+ set_progress_msg(PROG_FMT_PROCESS_INO, (uint64_t) mp->m_sb.sb_icount);
3133
3134 process_ags(mp);
3135
3136@@ -152,7 +152,7 @@ phase3(
3137 * process newly discovered inode chunks
3138 */
3139 do_log(_(" - process newly discovered inodes...\n"));
3140- set_progress_msg(PROG_FMT_NEW_INODES, (__uint64_t) glob_agcount);
3141+ set_progress_msg(PROG_FMT_NEW_INODES, (uint64_t) glob_agcount);
3142
3143 counts = calloc(sizeof(*counts), mp->m_sb.sb_agcount);
3144 if (!counts) {
3145diff --git a/repair/phase4.c b/repair/phase4.c
3146index e59464b1..cc17ec03 100644
3147--- a/repair/phase4.c
3148+++ b/repair/phase4.c
3149@@ -290,7 +290,7 @@ phase4(xfs_mount_t *mp)
3150 do_log(_("Phase 4 - check for duplicate blocks...\n"));
3151 do_log(_(" - setting up duplicate extent list...\n"));
3152
3153- set_progress_msg(PROG_FMT_DUP_EXTENT, (__uint64_t) glob_agcount);
3154+ set_progress_msg(PROG_FMT_DUP_EXTENT, (uint64_t) glob_agcount);
3155
3156 irec = find_inode_rec(mp, XFS_INO_TO_AGNO(mp, mp->m_sb.sb_rootino),
3157 XFS_INO_TO_AGINO(mp, mp->m_sb.sb_rootino));
3158@@ -404,7 +404,7 @@ phase4(xfs_mount_t *mp)
3159 reset_bmaps(mp);
3160
3161 do_log(_(" - check for inodes claiming duplicate blocks...\n"));
3162- set_progress_msg(PROG_FMT_DUP_BLOCKS, (__uint64_t) mp->m_sb.sb_icount);
3163+ set_progress_msg(PROG_FMT_DUP_BLOCKS, (uint64_t) mp->m_sb.sb_icount);
3164
3165 /*
3166 * ok, now process the inodes -- signal 2-pass check per inode.
3167diff --git a/repair/phase5.c b/repair/phase5.c
3168index 0b833f13..21dce67a 100644
3169--- a/repair/phase5.c
3170+++ b/repair/phase5.c
3171@@ -86,9 +86,9 @@ struct agi_stat {
3172 xfs_agino_t freecount;
3173 };
3174
3175-static __uint64_t *sb_icount_ag; /* allocated inodes per ag */
3176-static __uint64_t *sb_ifree_ag; /* free inodes per ag */
3177-static __uint64_t *sb_fdblocks_ag; /* free data blocks per ag */
3178+static uint64_t *sb_icount_ag; /* allocated inodes per ag */
3179+static uint64_t *sb_ifree_ag; /* free inodes per ag */
3180+static uint64_t *sb_fdblocks_ag; /* free data blocks per ag */
3181
3182 static int
3183 mk_incore_fstree(xfs_mount_t *mp, xfs_agnumber_t agno)
3184@@ -886,10 +886,10 @@ build_freespace_tree(xfs_mount_t *mp, xfs_agnumber_t agno,
3185 */
3186 static void
3187 init_ino_cursor(xfs_mount_t *mp, xfs_agnumber_t agno, bt_status_t *btree_curs,
3188- __uint64_t *num_inos, __uint64_t *num_free_inos, int finobt)
3189+ uint64_t *num_inos, uint64_t *num_free_inos, int finobt)
3190 {
3191- __uint64_t ninos;
3192- __uint64_t nfinos;
3193+ uint64_t ninos;
3194+ uint64_t nfinos;
3195 int rec_nfinos;
3196 int rec_ninos;
3197 ino_tree_node_t *ino_rec;
3198@@ -2193,10 +2193,10 @@ phase5_func(
3199 xfs_agnumber_t agno,
3200 struct xfs_slab *lost_fsb)
3201 {
3202- __uint64_t num_inos;
3203- __uint64_t num_free_inos;
3204- __uint64_t finobt_num_inos;
3205- __uint64_t finobt_num_free_inos;
3206+ uint64_t num_inos;
3207+ uint64_t num_free_inos;
3208+ uint64_t finobt_num_inos;
3209+ uint64_t finobt_num_free_inos;
3210 bt_status_t bno_btree_curs;
3211 bt_status_t bcnt_btree_curs;
3212 bt_status_t ino_btree_curs;
3213@@ -2471,7 +2471,7 @@ phase5(xfs_mount_t *mp)
3214 int error;
3215
3216 do_log(_("Phase 5 - rebuild AG headers and trees...\n"));
3217- set_progress_msg(PROG_FMT_REBUILD_AG, (__uint64_t )glob_agcount);
3218+ set_progress_msg(PROG_FMT_REBUILD_AG, (uint64_t)glob_agcount);
3219
3220 #ifdef XR_BLD_FREE_TRACE
3221 fprintf(stderr, "inobt level 1, maxrec = %d, minrec = %d\n",
3222@@ -2497,15 +2497,15 @@ phase5(xfs_mount_t *mp)
3223 keep_fsinos(mp);
3224
3225 /* allocate per ag counters */
3226- sb_icount_ag = calloc(mp->m_sb.sb_agcount, sizeof(__uint64_t));
3227+ sb_icount_ag = calloc(mp->m_sb.sb_agcount, sizeof(uint64_t));
3228 if (sb_icount_ag == NULL)
3229 do_error(_("cannot alloc sb_icount_ag buffers\n"));
3230
3231- sb_ifree_ag = calloc(mp->m_sb.sb_agcount, sizeof(__uint64_t));
3232+ sb_ifree_ag = calloc(mp->m_sb.sb_agcount, sizeof(uint64_t));
3233 if (sb_ifree_ag == NULL)
3234 do_error(_("cannot alloc sb_ifree_ag buffers\n"));
3235
3236- sb_fdblocks_ag = calloc(mp->m_sb.sb_agcount, sizeof(__uint64_t));
3237+ sb_fdblocks_ag = calloc(mp->m_sb.sb_agcount, sizeof(uint64_t));
3238 if (sb_fdblocks_ag == NULL)
3239 do_error(_("cannot alloc sb_fdblocks_ag buffers\n"));
3240
3241diff --git a/repair/phase6.c b/repair/phase6.c
3242index 08636dcf..373b1a5b 100644
3243--- a/repair/phase6.c
3244+++ b/repair/phase6.c
3245@@ -82,7 +82,7 @@ typedef struct dir_hash_ent {
3246 struct dir_hash_ent *nextbyhash; /* next in name bucket */
3247 struct dir_hash_ent *nextbyorder; /* next in order added */
3248 xfs_dahash_t hashval; /* hash value of name */
3249- __uint32_t address; /* offset of data entry */
3250+ uint32_t address; /* offset of data entry */
3251 xfs_ino_t inum; /* inode num of entry */
3252 short junkit; /* name starts with / */
3253 short seen; /* have seen leaf entry */
3254@@ -170,11 +170,11 @@ static int
3255 dir_hash_add(
3256 xfs_mount_t *mp,
3257 dir_hash_tab_t *hashtab,
3258- __uint32_t addr,
3259+ uint32_t addr,
3260 xfs_ino_t inum,
3261 int namelen,
3262 unsigned char *name,
3263- __uint8_t ftype)
3264+ uint8_t ftype)
3265 {
3266 xfs_dahash_t hash = 0;
3267 int byaddr;
3268@@ -357,7 +357,7 @@ static void
3269 dir_hash_update_ftype(
3270 dir_hash_tab_t *hashtab,
3271 xfs_dir2_dataptr_t addr,
3272- __uint8_t ftype)
3273+ uint8_t ftype)
3274 {
3275 int i;
3276 dir_hash_ent_t *p;
3277@@ -1791,8 +1791,8 @@ longform_dir2_entry_check_data(
3278
3279 /* validate ftype field if supported */
3280 if (xfs_sb_version_hasftype(&mp->m_sb)) {
3281- __uint8_t dir_ftype;
3282- __uint8_t ino_ftype;
3283+ uint8_t dir_ftype;
3284+ uint8_t ino_ftype;
3285
3286 dir_ftype = M_DIROPS(mp)->data_get_ftype(dep);
3287 ino_ftype = get_inode_ftype(irec, ino_offset);
3288@@ -2703,8 +2703,8 @@ _("entry \"%s\" (ino %" PRIu64 ") in dir %" PRIu64 " is a duplicate name"),
3289
3290 /* validate ftype field if supported */
3291 if (xfs_sb_version_hasftype(&mp->m_sb)) {
3292- __uint8_t dir_ftype;
3293- __uint8_t ino_ftype;
3294+ uint8_t dir_ftype;
3295+ uint8_t ino_ftype;
3296
3297 dir_ftype = M_DIROPS(mp)->sf_get_ftype(sfep);
3298 ino_ftype = get_inode_ftype(irec, ino_offset);
3299diff --git a/repair/phase7.c b/repair/phase7.c
3300index 8bce117d..4ffb81a8 100644
3301--- a/repair/phase7.c
3302+++ b/repair/phase7.c
3303@@ -32,7 +32,7 @@ static void
3304 update_inode_nlinks(
3305 xfs_mount_t *mp,
3306 xfs_ino_t ino,
3307- __uint32_t nlinks)
3308+ uint32_t nlinks)
3309 {
3310 xfs_trans_t *tp;
3311 xfs_inode_t *ip;
3312@@ -104,7 +104,7 @@ do_link_updates(
3313 {
3314 ino_tree_node_t *irec;
3315 int j;
3316- __uint32_t nrefs;
3317+ uint32_t nrefs;
3318
3319 for (irec = findfirst_inode_rec(agno); irec;
3320 irec = next_ino_rec(irec)) {
3321@@ -143,7 +143,7 @@ phase7(
3322 else
3323 do_log(_("Phase 7 - verify link counts...\n"));
3324
3325- set_progress_msg(PROGRESS_FMT_CORR_LINK, (__uint64_t) glob_agcount);
3326+ set_progress_msg(PROGRESS_FMT_CORR_LINK, (uint64_t) glob_agcount);
3327
3328 create_work_queue(&wq, mp, scan_threads);
3329
3330diff --git a/repair/progress.c b/repair/progress.c
3331index 2a09b239..99d2658c 100644
3332--- a/repair/progress.c
3333+++ b/repair/progress.c
3334@@ -85,8 +85,8 @@ pthread_t report_thread;
3335 typedef struct msg_block_s {
3336 pthread_mutex_t mutex;
3337 progress_rpt_t *format;
3338- __uint64_t *done;
3339- __uint64_t *total;
3340+ uint64_t *done;
3341+ uint64_t *total;
3342 int count;
3343 int interval;
3344 } msg_block_t;
3345@@ -96,14 +96,14 @@ typedef struct phase_times_s {
3346 time_t start;
3347 time_t end;
3348 time_t duration;
3349- __uint64_t item_counts[4];
3350+ uint64_t item_counts[4];
3351 } phase_times_t;
3352 static phase_times_t phase_times[8];
3353
3354 static void *progress_rpt_thread(void *);
3355 static int current_phase;
3356 static int running;
3357-static __uint64_t prog_rpt_total;
3358+static uint64_t prog_rpt_total;
3359
3360 void
3361 init_progress_rpt (void)
3362@@ -113,11 +113,11 @@ init_progress_rpt (void)
3363 * allocate the done vector
3364 */
3365
3366- if ((prog_rpt_done = (__uint64_t *)
3367- malloc(sizeof(__uint64_t)*glob_agcount)) == NULL ) {
3368+ if ((prog_rpt_done = (uint64_t *)
3369+ malloc(sizeof(uint64_t)*glob_agcount)) == NULL) {
3370 do_error(_("cannot malloc pointer to done vector\n"));
3371 }
3372- bzero(prog_rpt_done, sizeof(__uint64_t)*glob_agcount);
3373+ bzero(prog_rpt_done, sizeof(uint64_t)*glob_agcount);
3374
3375 /*
3376 * Setup comm block, start the thread
3377@@ -165,10 +165,10 @@ progress_rpt_thread (void *p)
3378 timer_t timerid;
3379 struct itimerspec timespec;
3380 char *msgbuf;
3381- __uint64_t *donep;
3382- __uint64_t sum;
3383+ uint64_t *donep;
3384+ uint64_t sum;
3385 msg_block_t *msgp = (msg_block_t *)p;
3386- __uint64_t percent;
3387+ uint64_t percent;
3388
3389 /* It's possible to get here very early w/ no progress msg set */
3390 if (!msgp->format)
3391@@ -286,7 +286,7 @@ progress_rpt_thread (void *p)
3392 }
3393
3394 int
3395-set_progress_msg (int report, __uint64_t total)
3396+set_progress_msg(int report, uint64_t total)
3397 {
3398
3399 if (!ag_stride)
3400@@ -300,7 +300,7 @@ set_progress_msg (int report, __uint64_t total)
3401
3402 /* reset all the accumulative totals */
3403 if (prog_rpt_done)
3404- bzero(prog_rpt_done, sizeof(__uint64_t)*glob_agcount);
3405+ bzero(prog_rpt_done, sizeof(uint64_t)*glob_agcount);
3406
3407 if (pthread_mutex_unlock(&global_msgs.mutex))
3408 do_error(_("set_progress_msg: cannot unlock progress mutex\n"));
3409@@ -308,14 +308,14 @@ set_progress_msg (int report, __uint64_t total)
3410 return (0);
3411 }
3412
3413-__uint64_t
3414+uint64_t
3415 print_final_rpt(void)
3416 {
3417 int i;
3418 struct tm *tmp;
3419 time_t now;
3420- __uint64_t *donep;
3421- __uint64_t sum;
3422+ uint64_t *donep;
3423+ uint64_t sum;
3424 msg_block_t *msgp = &global_msgs;
3425 char msgbuf[DURATION_BUF_SIZE];
3426
3427diff --git a/repair/progress.h b/repair/progress.h
3428index 33db8344..51526483 100644
3429--- a/repair/progress.h
3430+++ b/repair/progress.h
3431@@ -32,8 +32,8 @@
3432 extern void init_progress_rpt(void);
3433 extern void stop_progress_rpt(void);
3434 extern void summary_report(void);
3435-extern int set_progress_msg(int report, __uint64_t total);
3436-extern __uint64_t print_final_rpt(void);
3437+extern int set_progress_msg(int report, uint64_t total);
3438+extern uint64_t print_final_rpt(void);
3439 extern char *timestamp(int end, int phase, char *buf);
3440 extern char *duration(int val, char *buf);
3441 extern int do_parallel;
3442diff --git a/repair/rmap.c b/repair/rmap.c
3443index ab6e5839..01d6f0fc 100644
3444--- a/repair/rmap.c
3445+++ b/repair/rmap.c
3446@@ -343,7 +343,7 @@ err:
3447
3448 static int
3449 find_first_zero_bit(
3450- __uint64_t mask)
3451+ uint64_t mask)
3452 {
3453 int n;
3454 int b = 0;
3455@@ -356,7 +356,7 @@ find_first_zero_bit(
3456
3457 static int
3458 popcnt(
3459- __uint64_t mask)
3460+ uint64_t mask)
3461 {
3462 int n;
3463 int b = 0;
3464@@ -1064,14 +1064,14 @@ err:
3465 * Compare the key fields of two rmap records -- positive if key1 > key2,
3466 * negative if key1 < key2, and zero if equal.
3467 */
3468-__int64_t
3469+int64_t
3470 rmap_diffkeys(
3471 struct xfs_rmap_irec *kp1,
3472 struct xfs_rmap_irec *kp2)
3473 {
3474 __u64 oa;
3475 __u64 ob;
3476- __int64_t d;
3477+ int64_t d;
3478 struct xfs_rmap_irec tmp;
3479
3480 tmp = *kp1;
3481@@ -1081,7 +1081,7 @@ rmap_diffkeys(
3482 tmp.rm_flags &= ~XFS_RMAP_REC_FLAGS;
3483 ob = libxfs_rmap_irec_offset_pack(&tmp);
3484
3485- d = (__int64_t)kp1->rm_startblock - kp2->rm_startblock;
3486+ d = (int64_t)kp1->rm_startblock - kp2->rm_startblock;
3487 if (d)
3488 return d;
3489
3490@@ -1192,10 +1192,10 @@ fix_inode_reflink_flags(
3491 {
3492 struct ino_tree_node *irec;
3493 int bit;
3494- __uint64_t was;
3495- __uint64_t is;
3496- __uint64_t diff;
3497- __uint64_t mask;
3498+ uint64_t was;
3499+ uint64_t is;
3500+ uint64_t diff;
3501+ uint64_t mask;
3502 int error = 0;
3503 xfs_agino_t agino;
3504
3505diff --git a/repair/rmap.h b/repair/rmap.h
3506index 752ece82..1616ab7d 100644
3507--- a/repair/rmap.h
3508+++ b/repair/rmap.h
3509@@ -44,7 +44,7 @@ extern int rmap_init_cursor(xfs_agnumber_t, struct xfs_slab_cursor **);
3510 extern void rmap_avoid_check(void);
3511 extern int rmaps_verify_btree(struct xfs_mount *, xfs_agnumber_t);
3512
3513-extern __int64_t rmap_diffkeys(struct xfs_rmap_irec *kp1,
3514+extern int64_t rmap_diffkeys(struct xfs_rmap_irec *kp1,
3515 struct xfs_rmap_irec *kp2);
3516 extern void rmap_high_key_from_rec(struct xfs_rmap_irec *rec,
3517 struct xfs_rmap_irec *key);
3518diff --git a/repair/sb.c b/repair/sb.c
3519index 77e51546..acc92839 100644
3520--- a/repair/sb.c
3521+++ b/repair/sb.c
3522@@ -40,7 +40,7 @@ copy_sb(xfs_sb_t *source, xfs_sb_t *dest)
3523 xfs_ino_t uquotino;
3524 xfs_ino_t gquotino;
3525 xfs_ino_t pquotino;
3526- __uint16_t versionnum;
3527+ uint16_t versionnum;
3528
3529 rootino = dest->sb_rootino;
3530 rbmino = dest->sb_rbmino;
3531@@ -106,8 +106,8 @@ verify_sb_blocksize(xfs_sb_t *sb)
3532 static int
3533 __find_secondary_sb(
3534 xfs_sb_t *rsb,
3535- __uint64_t start,
3536- __uint64_t skip)
3537+ uint64_t start,
3538+ uint64_t skip)
3539 {
3540 xfs_off_t off;
3541 xfs_sb_t *sb;
3542@@ -187,13 +187,13 @@ __find_secondary_sb(
3543
3544 static int
3545 guess_default_geometry(
3546- __uint64_t *agsize,
3547- __uint64_t *agcount,
3548+ uint64_t *agsize,
3549+ uint64_t *agcount,
3550 libxfs_init_t *x)
3551 {
3552 struct fs_topology ft;
3553 int blocklog;
3554- __uint64_t dblocks;
3555+ uint64_t dblocks;
3556 int multidisk;
3557
3558 memset(&ft, 0, sizeof(ft));
3559@@ -216,9 +216,9 @@ int
3560 find_secondary_sb(xfs_sb_t *rsb)
3561 {
3562 int retval = 0;
3563- __uint64_t agcount;
3564- __uint64_t agsize;
3565- __uint64_t skip;
3566+ uint64_t agcount;
3567+ uint64_t agsize;
3568+ uint64_t skip;
3569 int blocklog;
3570
3571 /*
3572@@ -229,7 +229,7 @@ find_secondary_sb(xfs_sb_t *rsb)
3573 do_warn(_("\nattempting to find secondary superblock...\n"));
3574
3575 if (verify_sb_blocksize(rsb) == 0) {
3576- skip = (__uint64_t)rsb->sb_agblocks * rsb->sb_blocksize;
3577+ skip = (uint64_t)rsb->sb_agblocks * rsb->sb_blocksize;
3578 if (skip >= XFS_AG_MIN_BYTES && skip <= XFS_AG_MAX_BYTES)
3579 retval = __find_secondary_sb(rsb, skip, skip);
3580 }
3581@@ -343,7 +343,7 @@ sb_validate_ino_align(struct xfs_sb *sb)
3582 int
3583 verify_sb(char *sb_buf, xfs_sb_t *sb, int is_primary_sb)
3584 {
3585- __uint32_t bsize;
3586+ uint32_t bsize;
3587 int i;
3588 int ret;
3589
3590@@ -399,7 +399,7 @@ verify_sb(char *sb_buf, xfs_sb_t *sb, int is_primary_sb)
3591 sb->sb_dblocks < XFS_MIN_DBLOCKS(sb))
3592 return(XR_BAD_FS_SIZE_DATA);
3593
3594- if (sb->sb_agblklog != (__uint8_t)libxfs_log2_roundup(sb->sb_agblocks))
3595+ if (sb->sb_agblklog != (uint8_t)libxfs_log2_roundup(sb->sb_agblocks))
3596 return(XR_BAD_FS_SIZE_DATA);
3597
3598 if (sb->sb_inodesize < XFS_DINODE_MIN_SIZE ||
3599diff --git a/repair/scan.c b/repair/scan.c
3600index b9ef4dc3..447611ac 100644
3601--- a/repair/scan.c
3602+++ b/repair/scan.c
3603@@ -42,13 +42,13 @@ struct aghdr_cnts {
3604 xfs_agnumber_t agno;
3605 xfs_extlen_t agffreeblks;
3606 xfs_extlen_t agflongest;
3607- __uint64_t agfbtreeblks;
3608- __uint32_t agicount;
3609- __uint32_t agifreecount;
3610- __uint64_t fdblocks;
3611- __uint64_t usedblocks;
3612- __uint64_t ifreecount;
3613- __uint32_t fibtfreecount;
3614+ uint64_t agfbtreeblks;
3615+ uint32_t agicount;
3616+ uint32_t agifreecount;
3617+ uint64_t fdblocks;
3618+ uint64_t usedblocks;
3619+ uint64_t ifreecount;
3620+ uint32_t fibtfreecount;
3621 };
3622
3623 void
3624@@ -70,10 +70,10 @@ scan_sbtree(
3625 xfs_agnumber_t agno,
3626 int suspect,
3627 int isroot,
3628- __uint32_t magic,
3629+ uint32_t magic,
3630 void *priv),
3631 int isroot,
3632- __uint32_t magic,
3633+ uint32_t magic,
3634 void *priv,
3635 const struct xfs_buf_ops *ops)
3636 {
3637@@ -110,23 +110,23 @@ scan_lbtree(
3638 xfs_fsblock_t bno,
3639 xfs_ino_t ino,
3640 xfs_rfsblock_t *tot,
3641- __uint64_t *nex,
3642+ uint64_t *nex,
3643 blkmap_t **blkmapp,
3644 bmap_cursor_t *bm_cursor,
3645 int isroot,
3646 int check_dups,
3647 int *dirty,
3648- __uint64_t magic),
3649+ uint64_t magic),
3650 int type,
3651 int whichfork,
3652 xfs_ino_t ino,
3653 xfs_rfsblock_t *tot,
3654- __uint64_t *nex,
3655+ uint64_t *nex,
3656 blkmap_t **blkmapp,
3657 bmap_cursor_t *bm_cursor,
3658 int isroot,
3659 int check_dups,
3660- __uint64_t magic,
3661+ uint64_t magic,
3662 const struct xfs_buf_ops *ops)
3663 {
3664 xfs_buf_t *bp;
3665@@ -179,13 +179,13 @@ scan_bmapbt(
3666 xfs_fsblock_t bno,
3667 xfs_ino_t ino,
3668 xfs_rfsblock_t *tot,
3669- __uint64_t *nex,
3670+ uint64_t *nex,
3671 blkmap_t **blkmapp,
3672 bmap_cursor_t *bm_cursor,
3673 int isroot,
3674 int check_dups,
3675 int *dirty,
3676- __uint64_t magic)
3677+ uint64_t magic)
3678 {
3679 int i;
3680 int err;
3681@@ -548,7 +548,7 @@ scan_allocbt(
3682 xfs_agnumber_t agno,
3683 int suspect,
3684 int isroot,
3685- __uint32_t magic,
3686+ uint32_t magic,
3687 void *priv)
3688 {
3689 struct aghdr_cnts *agcnts = priv;
3690@@ -930,7 +930,7 @@ scan_rmapbt(
3691 xfs_agnumber_t agno,
3692 int suspect,
3693 int isroot,
3694- __uint32_t magic,
3695+ uint32_t magic,
3696 void *priv)
3697 {
3698 const char *name = "rmap";
3699@@ -1233,7 +1233,7 @@ scan_refcbt(
3700 xfs_agnumber_t agno,
3701 int suspect,
3702 int isroot,
3703- __uint32_t magic,
3704+ uint32_t magic,
3705 void *priv)
3706 {
3707 const char *name = "refcount";
3708@@ -1939,7 +1939,7 @@ scan_inobt(
3709 xfs_agnumber_t agno,
3710 int suspect,
3711 int isroot,
3712- __uint32_t magic,
3713+ uint32_t magic,
3714 void *priv)
3715 {
3716 struct aghdr_cnts *agcnts = priv;
3717@@ -2176,7 +2176,7 @@ validate_agf(
3718 struct aghdr_cnts *agcnts)
3719 {
3720 xfs_agblock_t bno;
3721- __uint32_t magic;
3722+ uint32_t magic;
3723
3724 bno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNO]);
3725 if (bno != 0 && verify_agbno(mp, agno, bno)) {
3726@@ -2274,7 +2274,7 @@ validate_agi(
3727 {
3728 xfs_agblock_t bno;
3729 int i;
3730- __uint32_t magic;
3731+ uint32_t magic;
3732
3733 bno = be32_to_cpu(agi->agi_root);
3734 if (bno != 0 && verify_agbno(mp, agno, bno)) {
3735@@ -2499,10 +2499,10 @@ scan_ags(
3736 int scan_threads)
3737 {
3738 struct aghdr_cnts *agcnts;
3739- __uint64_t fdblocks = 0;
3740- __uint64_t icount = 0;
3741- __uint64_t ifreecount = 0;
3742- __uint64_t usedblocks = 0;
3743+ uint64_t fdblocks = 0;
3744+ uint64_t icount = 0;
3745+ uint64_t ifreecount = 0;
3746+ uint64_t usedblocks = 0;
3747 xfs_agnumber_t i;
3748 work_queue_t wq;
3749
3750diff --git a/repair/scan.h b/repair/scan.h
3751index ea8c0bf2..9bbe1e69 100644
3752--- a/repair/scan.h
3753+++ b/repair/scan.h
3754@@ -30,23 +30,23 @@ int scan_lbtree(
3755 xfs_fsblock_t bno,
3756 xfs_ino_t ino,
3757 xfs_rfsblock_t *tot,
3758- __uint64_t *nex,
3759+ uint64_t *nex,
3760 struct blkmap **blkmapp,
3761 bmap_cursor_t *bm_cursor,
3762 int isroot,
3763 int check_dups,
3764 int *dirty,
3765- __uint64_t magic),
3766+ uint64_t magic),
3767 int type,
3768 int whichfork,
3769 xfs_ino_t ino,
3770 xfs_rfsblock_t *tot,
3771- __uint64_t *nex,
3772+ uint64_t *nex,
3773 struct blkmap **blkmapp,
3774 bmap_cursor_t *bm_cursor,
3775 int isroot,
3776 int check_dups,
3777- __uint64_t magic,
3778+ uint64_t magic,
3779 const struct xfs_buf_ops *ops);
3780
3781 int scan_bmapbt(
3782@@ -57,13 +57,13 @@ int scan_bmapbt(
3783 xfs_fsblock_t bno,
3784 xfs_ino_t ino,
3785 xfs_rfsblock_t *tot,
3786- __uint64_t *nex,
3787+ uint64_t *nex,
3788 struct blkmap **blkmapp,
3789 bmap_cursor_t *bm_cursor,
3790 int isroot,
3791 int check_dups,
3792 int *dirty,
3793- __uint64_t magic);
3794+ uint64_t magic);
3795
3796 void
3797 scan_ags(
3798--
37992.14.1
3800
diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/remove_flags_from_build_flags.patch b/meta-filesystems/recipes-utils/xfsprogs/files/remove_flags_from_build_flags.patch
index bba9a25c2..bd2d02563 100644
--- a/meta-filesystems/recipes-utils/xfsprogs/files/remove_flags_from_build_flags.patch
+++ b/meta-filesystems/recipes-utils/xfsprogs/files/remove_flags_from_build_flags.patch
@@ -1,13 +1,13 @@
1Index: xfsprogs-4.12.0/include/builddefs.in 1Index: xfsprogs-4.14.0/include/builddefs.in
2=================================================================== 2===================================================================
3--- xfsprogs-4.12.0.orig/include/builddefs.in 3--- xfsprogs-4.14.0.orig/include/builddefs.in
4+++ xfsprogs-4.12.0/include/builddefs.in 4+++ xfsprogs-4.14.0/include/builddefs.in
5@@ -164,7 +164,7 @@ ifeq ($(ENABLE_GETTEXT),yes) 5@@ -168,7 +168,7 @@ ifeq ($(ENABLE_GETTEXT),yes)
6 GCFLAGS += -DENABLE_GETTEXT 6 GCFLAGS += -DENABLE_GETTEXT
7 endif 7 endif
8 8
9-BUILD_CFLAGS += $(GCFLAGS) $(PCFLAGS) 9-BUILD_CFLAGS += $(GCFLAGS) $(PCFLAGS)
10+BUILD_CFLAGS += $(GCFLAGS) 10+BUILD_CFLAGS += $(GCFLAGS)
11 # First, Global, Platform, Local CFLAGS 11 # First, Sanitizer, Global, Platform, Local CFLAGS
12 CFLAGS += $(FCFLAGS) $(OPTIMIZER) $(GCFLAGS) $(PCFLAGS) $(LCFLAGS) 12 CFLAGS += $(FCFLAGS) $(SANITIZER_CFLAGS) $(OPTIMIZER) $(GCFLAGS) $(PCFLAGS) $(LCFLAGS)
13 13
diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/xfsprogs-4.12.0-fix_musl.patch b/meta-filesystems/recipes-utils/xfsprogs/files/xfsprogs-4.12.0-fix_musl.patch
deleted file mode 100644
index efc57e4f6..000000000
--- a/meta-filesystems/recipes-utils/xfsprogs/files/xfsprogs-4.12.0-fix_musl.patch
+++ /dev/null
@@ -1,117 +0,0 @@
1From 21253610f9ef87db8e2a75b863b7fcfbd0cdb421 Mon Sep 17 00:00:00 2001
2From: "Darrick J. Wong" <darrick.wong@oracle.com>
3Date: Tue, 25 Jul 2017 13:45:01 -0500
4Subject: [PATCH] In patch 4944defad4 ("xfs_db: redirect printfs when
5 metadumping to stdout"), we solved the problem of xfs_db printfs ending up in
6 the metadump stream by reassigning stdout for the duration of a stdout
7 metadump. Unfortunately, musl doesn't allow stdout to be reassigned (in
8 their view "extern FILE *stdout" means "extern FILE * const stdout"), so we
9 abandon the old approach in favor of playing games with dup() to switch the
10 raw file descriptors.
11
12While we're at it, fix a regression where an unconverted outf test
13allows progress info to end up in the metadump stream.
14
15Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
16---
17 db/metadump.c | 47 ++++++++++++++++++++++++++++++++++++-----------
18 1 file changed, 36 insertions(+), 11 deletions(-)
19
20diff --git a/db/metadump.c b/db/metadump.c
21index 96641e0..4e2f648 100644
22--- a/db/metadump.c
23+++ b/db/metadump.c
24@@ -78,6 +78,7 @@ static int obfuscate = 1;
25 static int zero_stale_data = 1;
26 static int show_warnings = 0;
27 static int progress_since_warning = 0;
28+static bool stdout_metadump;
29
30 void
31 metadump_init(void)
32@@ -137,7 +138,7 @@ print_progress(const char *fmt, ...)
33 va_end(ap);
34 buf[sizeof(buf)-1] = '\0';
35
36- f = (outf == stdout) ? stderr : stdout;
37+ f = stdout_metadump ? stderr : stdout;
38 fprintf(f, "\r%-59s", buf);
39 fflush(f);
40 progress_since_warning = 1;
41@@ -2750,7 +2751,8 @@ metadump_f(
42 xfs_agnumber_t agno;
43 int c;
44 int start_iocur_sp;
45- bool stdout_metadump = false;
46+ int outfd = -1;
47+ int ret;
48 char *p;
49
50 exitcode = 1;
51@@ -2870,16 +2872,35 @@ metadump_f(
52 * metadump operation so that dbprintf and other messages
53 * are sent to the console instead of polluting the
54 * metadump stream.
55+ *
56+ * We get to do this the hard way because musl doesn't
57+ * allow reassignment of stdout.
58 */
59- outf = stdout;
60- stdout = stderr;
61+ fflush(stdout);
62+ outfd = dup(STDOUT_FILENO);
63+ if (outfd < 0) {
64+ perror("opening dump stream");
65+ goto out;
66+ }
67+ ret = dup2(STDERR_FILENO, STDOUT_FILENO);
68+ if (ret < 0) {
69+ perror("redirecting stdout");
70+ close(outfd);
71+ goto out;
72+ }
73+ outf = fdopen(outfd, "a");
74+ if (outf == NULL) {
75+ fprintf(stderr, "cannot create dump stream\n");
76+ dup2(outfd, 1);
77+ close(outfd);
78+ goto out;
79+ }
80 stdout_metadump = true;
81 } else {
82 outf = fopen(argv[optind], "wb");
83 if (outf == NULL) {
84 print_warning("cannot create dump file");
85- free(metablock);
86- return 0;
87+ goto out;
88 }
89 }
90
91@@ -2907,15 +2928,19 @@ metadump_f(
92 if (progress_since_warning)
93 fputc('\n', stdout_metadump ? stderr : stdout);
94
95- if (stdout_metadump)
96- stdout = outf;
97- else
98- fclose(outf);
99+ if (stdout_metadump) {
100+ fflush(outf);
101+ fflush(stdout);
102+ ret = dup2(outfd, STDOUT_FILENO);
103+ if (ret < 0)
104+ perror("un-redirecting stdout");
105+ }
106+ fclose(outf);
107
108 /* cleanup iocur stack */
109 while (iocur_sp > start_iocur_sp)
110 pop_cur();
111-
112+out:
113 free(metablock);
114
115 return 0;
116--
1172.13.3
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2024-11-12 01:22:27 +0000