summaryrefslogtreecommitdiffstats
path: root/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch
diff options
context:
space:
mode:
Diffstat (limited to 'meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch')
-rw-r--r--meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch3800
1 files changed, 0 insertions, 3800 deletions
diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch b/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch
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
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2024-09-23 23:29:20 +0000