From patchwork Sat Sep 9 01:57:35 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Khem Raj X-Patchwork-Id: 112140 Delivered-To: patch@linaro.org Received: by 10.140.106.117 with SMTP id d108csp1052622qgf; Fri, 8 Sep 2017 18:57:52 -0700 (PDT) X-Received: by 10.84.238.204 with SMTP id l12mr5501693pln.196.1504922272042; Fri, 08 Sep 2017 18:57:52 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1504922272; cv=none; d=google.com; s=arc-20160816; b=ipucdA9mEWdNHYKepok1GfScrPB7m19LV69H677UvQL76GrExWs+cf5pb0uY/rWgFu gN92mtMhuRfj5Pd2VxpXC6ZrT0TCt1/E8tthBGUYdLrQ/CnjuHhk2ql82HnhDBElvHy5 fsq1LdDD6ZT91bOvn2cOK4AMRxXpuf6pSfhKkuhWjpyrhfcB/LPwg/iEMy6aUEU9rypo Bx6Ja9lAf8pbTiO8WHGw4MPHua4GOKipiUeF57ut6bV6R31k5raFX8tkSPMx8SOlylGT JFAXbR9blf8pLan6+oX8fxHgiTKQpHKfnawqkTJ+XQbJDYWuy/WJVfcPobdktTiT+SGI VJ0w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:sender:content-transfer-encoding:mime-version :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:message-id:date:to:from:dkim-signature :delivered-to:arc-authentication-results; bh=aHKgWmkvdvMF15l/t8F6g3lQkEWzUs9u8hfZFE0Am90=; b=aQ5b2ux0mPm2cFMC9vQBzw/Gwf+0/JstylnZiJVq3VP2Z2dJhJ4obx41k0Vf4RYV+J eg05kYtIxV2Q+WLK9QWLOSTXUknzDUuqVn8attVHwBsjSb3+9kgDdE57aTjmK9T40Kpl PSu6cp8hNw5BevL6HWD5IAUj1tCS8w5aqwZcJWQsvtg1TGJmFJ4M3Ikw2aCUHOM3qTE1 QxSsh2I7soiqMBzIowrZAcCGgP9JtXtZNmyhHZjH7RMdHKmBRP7hVB2VPm2cns0jeqM0 d4bVxdb2Ydfz8Q02HB7ET1VwqAmyM4dbdsYWh7mNSsb7rXAb/0iYEZG/8Cpzznk9SCTY v1Pw== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@gmail.com header.s=20161025 header.b=l5rWFsLY; spf=pass (google.com: best guess record for domain of openembedded-devel-bounces@lists.openembedded.org designates 140.211.169.62 as permitted sender) smtp.mailfrom=openembedded-devel-bounces@lists.openembedded.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=gmail.com Return-Path: Received: from mail.openembedded.org (mail.openembedded.org. [140.211.169.62]) by mx.google.com with ESMTP id z7si2413272pgp.46.2017.09.08.18.57.50; Fri, 08 Sep 2017 18:57:52 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of openembedded-devel-bounces@lists.openembedded.org designates 140.211.169.62 as permitted sender) client-ip=140.211.169.62; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@gmail.com header.s=20161025 header.b=l5rWFsLY; spf=pass (google.com: best guess record for domain of openembedded-devel-bounces@lists.openembedded.org designates 140.211.169.62 as permitted sender) smtp.mailfrom=openembedded-devel-bounces@lists.openembedded.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=gmail.com Received: from review.yoctoproject.org (localhost [127.0.0.1]) by mail.openembedded.org (Postfix) with ESMTP id 28F9E7825C; Sat, 9 Sep 2017 01:57:45 +0000 (UTC) X-Original-To: openembedded-devel@lists.openembedded.org Delivered-To: openembedded-devel@lists.openembedded.org Received: from mail-pf0-f175.google.com (mail-pf0-f175.google.com [209.85.192.175]) by mail.openembedded.org (Postfix) with ESMTP id 173A378242 for ; Sat, 9 Sep 2017 01:57:43 +0000 (UTC) Received: by mail-pf0-f175.google.com with SMTP id e1so6924576pfk.1 for ; Fri, 08 Sep 2017 18:57:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id; bh=0t67PWHKUtRFH1P9Wury9+2+J8I270Qn0qEEl4fwFuY=; b=l5rWFsLY8U2NjV47Lu27n5geb775B1KeUzego0nm5s7q9IxzbPJnkczl9GwSqMlYSE tQvh3MJPKshEkXucQKHyBF7UhPcv8vAp9H5iPFLcY4l9k9vqZB6x8qbyzQ0RfyD0Pmjn IUK+WRSsHtZhZy1oo6pQVMJoJHf8t6YLG4m+w9abd/B3D/C6VsnY1JOqiPV8KfQbSSW7 YK+Pn7qvE1pTj7A1mSDSsPCqSDD3qVkuUjZvJQXikj2g0qaC68rYc9cGQosPs9kcsp19 mbPuK1wx/AhwQhWL6dgd+CqE6V9SCGsretAjkuqAAwst4E9iC10xGGvBOFpuB8yZm9FV 1WgA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id; bh=0t67PWHKUtRFH1P9Wury9+2+J8I270Qn0qEEl4fwFuY=; b=azee82r0QblT1Parx3nkMdy7HO7qrdPb0l03h+ruPwvjX9PT435QKnEc4MhplXAqg8 9P7fIZNvuQTN8ef6gmnmnIBxxHBjAXcbvH9BH0W2vLNu8VPjwtZM9fAnInM9CHhc9zkm +QENEx8wVN4kgeczfvnWsbh7BJvPTU4vkFzxfPf3iwMy3mB9JplaV/rCMqjl5JA94PZi ZLvzKIcIeIjoi2GYWiFYAHglfJ7iSQUVxg81DstJ9R6ZrxE7qu39loon4KJSs6g8Bhw7 rYzfQTzNuH3ezTTK8GEdu4y9q63IjLaJztkcdqQKqhuyXnnxeZA9Rms2oFMLyzAS0TPx 0FAQ== X-Gm-Message-State: AHPjjUiwBbS0pQuWS8BlteDxGyAz/n4K1qrfOyqGuis3lAnqoEFqJS5t ZkoQjhMc8ItEuFlI X-Google-Smtp-Source: ADKCNb6d0JLJqawqCN+TfVbSuqfnGOQdOuQjOMsvRKtHp6eVG3o3ogFHg2Lg1/aA69VsbtLJjg1T2Q== X-Received: by 10.98.212.26 with SMTP id a26mr2848782pfh.333.1504922263391; Fri, 08 Sep 2017 18:57:43 -0700 (PDT) Received: from localhost.localdomain ([2601:646:8882:b8c::be3d]) by smtp.gmail.com with ESMTPSA id d126sm4996390pgc.85.2017.09.08.18.57.42 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Fri, 08 Sep 2017 18:57:42 -0700 (PDT) From: Khem Raj To: openembedded-devel@lists.openembedded.org Date: Fri, 8 Sep 2017 18:57:35 -0700 Message-Id: <20170909015735.32308-1-raj.khem@gmail.com> X-Mailer: git-send-email 2.14.1 Subject: [oe] [meta-filesystems][PATCH V5] xfsprogs: Upgrade to 4.12.0 X-BeenThere: openembedded-devel@lists.openembedded.org X-Mailman-Version: 2.1.12 Precedence: list List-Id: Using the OpenEmbedded metadata to build Distributions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Sender: openembedded-devel-bounces@lists.openembedded.org Errors-To: openembedded-devel-bounces@lists.openembedded.org Fix cross builds with hardening flags Fix build with gold Specify libtool tag Add DISABLE_STATIC = "" Signed-off-by: Khem Raj --- Changes in V5: Drop local patches for upstreamed patches for u_int change ...fine-__-prefixed-version-of-intXY_t-types.patch | 58 - ...gs-remove-double-underscore-integer-types.patch | 3800 ++++++++++++++++++++ ...move-remaining-double-underscore-integer-.patch | 2046 +++++++++++ .../xfsprogs/files/link_needed_libs.patch | 82 - .../files/remove_flags_from_build_flags.patch | 13 + .../xfsprogs/files/xfsprogs-4.12.0-fix_musl.patch | 117 + .../{xfsprogs_4.11.0.bb => xfsprogs_4.12.0.bb} | 12 +- 7 files changed, 5984 insertions(+), 144 deletions(-) delete mode 100644 meta-filesystems/recipes-utils/xfsprogs/files/0001-define-__-prefixed-version-of-intXY_t-types.patch create mode 100644 meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch create mode 100644 meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-remaining-double-underscore-integer-.patch delete mode 100644 meta-filesystems/recipes-utils/xfsprogs/files/link_needed_libs.patch create mode 100644 meta-filesystems/recipes-utils/xfsprogs/files/remove_flags_from_build_flags.patch create mode 100644 meta-filesystems/recipes-utils/xfsprogs/files/xfsprogs-4.12.0-fix_musl.patch rename meta-filesystems/recipes-utils/xfsprogs/{xfsprogs_4.11.0.bb => xfsprogs_4.12.0.bb} (79%) -- 2.14.1 -- _______________________________________________ Openembedded-devel mailing list Openembedded-devel@lists.openembedded.org http://lists.openembedded.org/mailman/listinfo/openembedded-devel diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/0001-define-__-prefixed-version-of-intXY_t-types.patch b/meta-filesystems/recipes-utils/xfsprogs/files/0001-define-__-prefixed-version-of-intXY_t-types.patch deleted file mode 100644 index 951a1442c..000000000 --- a/meta-filesystems/recipes-utils/xfsprogs/files/0001-define-__-prefixed-version-of-intXY_t-types.patch +++ /dev/null @@ -1,58 +0,0 @@ -From 2b4714123cdecb558babb76074d0ab945bf5b177 Mon Sep 17 00:00:00 2001 -From: Khem Raj -Date: Fri, 16 Jun 2017 18:59:10 -0700 -Subject: [PATCH] define __ prefixed version of intXY_t types - -This is required since musl does not define them -unlike glibc - -Upstream-Status: Pending - -Signed-off-by: Khem Raj ---- - include/linux.h | 29 +++++++++++++++++++++++++++++ - 1 file changed, 29 insertions(+) - -diff --git a/include/linux.h b/include/linux.h -index 6a676ca..6976d83 100644 ---- a/include/linux.h -+++ b/include/linux.h -@@ -40,6 +40,35 @@ - # undef fsxattr - #endif - -+#ifndef loff_t -+#define loff_t off_t -+#endif -+#ifndef __uint8_t -+#define __uint8_t uint8_t -+#endif -+#ifndef __uint16_t -+#define __uint16_t uint16_t -+#endif -+#ifndef __uint32_t -+#define __uint32_t uint32_t -+#endif -+#ifndef __uint64_t -+#define __uint64_t uint64_t -+#endif -+ -+#ifndef __int8_t -+#define __int8_t int8_t -+#endif -+#ifndef __int16_t -+#define __int16_t int16_t -+#endif -+#ifndef __int32_t -+#define __int32_t int32_t -+#endif -+#ifndef __int64_t -+#define __int64_t int64_t -+#endif -+ - static __inline__ int xfsctl(const char *path, int fd, int cmd, void *p) - { - return ioctl(fd, cmd, p); --- -2.13.1 - 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 new file mode 100644 index 000000000..5e08f0d84 --- /dev/null +++ b/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-double-underscore-integer-types.patch @@ -0,0 +1,3800 @@ +From 14f8b6810bd240cc58131483790a099fcf56c073 Mon Sep 17 00:00:00 2001 +From: "Darrick J. Wong" +Date: Fri, 4 Aug 2017 16:33:51 -0500 +Subject: [PATCH] xfsprogs: remove double-underscore integer types + +This is a purely mechanical patch that removes the private +__{u,}int{8,16,32,64}_t typedefs in favor of using the system +{u,}int{8,16,32,64}_t typedefs. This is the sed script used to perform +the transformation and fix the resulting whitespace and indentation +errors: + +s/typedef\t__uint8_t/typedef __uint8_t\t/g +s/typedef\t__uint/typedef __uint/g +s/typedef\t__int\([0-9]*\)_t/typedef int\1_t\t/g +s/__uint8_t\t/__uint8_t\t\t/g +s/__uint/uint/g +s/__int\([0-9]*\)_t\t/__int\1_t\t\t/g +s/__int/int/g +/^typedef.*int[0-9]*_t;$/d + +Signed-off-by: Darrick J. Wong +Reviewed-by: Carlos Maiolino +[sandeen: fix whitespace incidentals] +Reviewed-by: Darrick J. Wong +Signed-off-by: Eric Sandeen +--- + copy/xfs_copy.c | 14 ++++----- + copy/xfs_copy.h | 2 +- + db/attr.c | 8 ++--- + db/attrshort.c | 4 +-- + db/bit.c | 4 +-- + db/bit.h | 2 +- + db/block.c | 8 ++--- + db/check.c | 18 +++++------ + db/convert.c | 28 ++++++++--------- + db/faddr.c | 14 ++++----- + db/field.c | 44 +++++++++++++-------------- + db/fprint.c | 8 ++--- + db/frag.c | 8 ++--- + db/inode.c | 34 ++++++++++----------- + db/io.c | 2 +- + db/io.h | 6 ++-- + db/metadump.c | 12 ++++---- + db/sb.c | 6 ++-- + fsr/xfs_fsr.c | 2 +- + include/darwin.h | 18 +++++------ + include/freebsd.h | 6 ++-- + include/gnukfreebsd.h | 6 ++-- + include/libxcmd.h | 6 ++-- + include/linux.h | 8 ++--- + include/xfs_arch.h | 22 +++++++------- + include/xfs_inode.h | 4 +-- + include/xfs_log_recover.h | 2 +- + include/xfs_metadump.h | 4 +-- + include/xfs_mount.h | 22 +++++++------- + libhandle/handle.c | 2 +- + libhandle/jdm.c | 2 +- + libxcmd/topology.c | 14 ++++----- + libxfs/darwin.c | 2 +- + libxfs/freebsd.c | 2 +- + libxfs/init.c | 2 +- + libxfs/irix.c | 2 +- + libxfs/libxfs_priv.h | 4 +-- + libxfs/linux.c | 2 +- + libxfs/logitem.c | 2 +- + libxfs/radix-tree.c | 8 ++--- + libxfs/rdwr.c | 6 ++-- + libxfs/util.c | 8 ++--- + logprint/log_misc.c | 6 ++-- + mdrestore/xfs_mdrestore.c | 2 +- + mkfs/proto.c | 2 +- + mkfs/xfs_mkfs.c | 76 +++++++++++++++++++++++------------------------ + quota/edit.c | 64 +++++++++++++++++++-------------------- + quota/free.c | 44 +++++++++++++-------------- + quota/quot.c | 24 +++++++-------- + quota/quota.c | 4 +-- + quota/quota.h | 12 ++++---- + quota/report.c | 4 +-- + quota/state.c | 2 +- + quota/util.c | 66 ++++++++++++++++++++-------------------- + repair/README | 2 +- + repair/agheader.h | 14 ++++----- + repair/attr_repair.h | 26 ++++++++-------- + repair/avl64.c | 38 ++++++++++++------------ + repair/avl64.h | 18 +++++------ + repair/dinode.c | 38 ++++++++++++------------ + repair/dinode.h | 4 +-- + repair/dir2.c | 2 +- + repair/globals.h | 18 +++++------ + repair/incore.c | 10 +++---- + repair/incore.h | 46 ++++++++++++++-------------- + repair/incore_ext.c | 6 ++-- + repair/incore_ino.c | 72 ++++++++++++++++++++++---------------------- + repair/phase2.c | 2 +- + repair/phase3.c | 6 ++-- + repair/phase4.c | 4 +-- + repair/phase5.c | 28 ++++++++--------- + repair/phase6.c | 16 +++++----- + repair/phase7.c | 6 ++-- + repair/progress.c | 30 +++++++++---------- + repair/progress.h | 4 +-- + repair/rmap.c | 18 +++++------ + repair/rmap.h | 2 +- + repair/sb.c | 24 +++++++-------- + repair/scan.c | 50 +++++++++++++++---------------- + repair/scan.h | 12 ++++---- + 80 files changed, 590 insertions(+), 590 deletions(-) + +diff --git a/copy/xfs_copy.c b/copy/xfs_copy.c +index a7da824f..33e05dfd 100644 +--- a/copy/xfs_copy.c ++++ b/copy/xfs_copy.c +@@ -43,7 +43,7 @@ unsigned int source_sectorsize; /* source disk sectorsize */ + + xfs_agblock_t first_agbno; + +-__uint64_t barcount[11]; ++uint64_t barcount[11]; + + unsigned int num_targets; + target_control *target; +@@ -313,7 +313,7 @@ usage(void) + } + + void +-init_bar(__uint64_t source_blocks) ++init_bar(uint64_t source_blocks) + { + int i; + +@@ -322,7 +322,7 @@ init_bar(__uint64_t source_blocks) + } + + int +-bump_bar(int tenths, __uint64_t numblocks) ++bump_bar(int tenths, uint64_t numblocks) + { + static char *bar[11] = { + " 0% ", +@@ -534,8 +534,8 @@ main(int argc, char **argv) + xfs_off_t pos; + size_t length; + int c; +- __uint64_t size, sizeb; +- __uint64_t numblocks = 0; ++ uint64_t size, sizeb; ++ uint64_t numblocks = 0; + int wblocks = 0; + int num_threads = 0; + struct dioattr d; +@@ -951,8 +951,8 @@ main(int argc, char **argv) + num_ags = mp->m_sb.sb_agcount; + + init_bar(mp->m_sb.sb_blocksize / BBSIZE +- * ((__uint64_t)mp->m_sb.sb_dblocks +- - (__uint64_t)mp->m_sb.sb_fdblocks + 10 * num_ags)); ++ * ((uint64_t)mp->m_sb.sb_dblocks ++ - (uint64_t)mp->m_sb.sb_fdblocks + 10 * num_ags)); + + kids = num_targets; + +diff --git a/copy/xfs_copy.h b/copy/xfs_copy.h +index 27370688..53c6e42c 100644 +--- a/copy/xfs_copy.h ++++ b/copy/xfs_copy.h +@@ -76,7 +76,7 @@ typedef struct { + + typedef int thread_id; + typedef int tm_index; /* index into thread mask array */ +-typedef __uint32_t thread_mask; /* a thread mask */ ++typedef uint32_t thread_mask; /* a thread mask */ + + typedef struct { + char *name; +diff --git a/db/attr.c b/db/attr.c +index 31536a8b..23ffcd5f 100644 +--- a/db/attr.c ++++ b/db/attr.c +@@ -77,16 +77,16 @@ const field_t attr_leaf_entry_flds[] = { + { "nameidx", FLDT_UINT16D, OI(LEOFF(nameidx)), C1, 0, TYP_NONE }, + { "flags", FLDT_UINT8X, OI(LEOFF(flags)), C1, FLD_SKIPALL, TYP_NONE }, + { "incomplete", FLDT_UINT1, +- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_INCOMPLETE_BIT - 1), C1, ++ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_INCOMPLETE_BIT - 1), C1, + 0, TYP_NONE }, + { "root", FLDT_UINT1, +- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0, ++ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0, + TYP_NONE }, + { "secure", FLDT_UINT1, +- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0, ++ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0, + TYP_NONE }, + { "local", FLDT_UINT1, +- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_LOCAL_BIT - 1), C1, 0, ++ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_LOCAL_BIT - 1), C1, 0, + TYP_NONE }, + { "pad2", FLDT_UINT8X, OI(LEOFF(pad2)), C1, FLD_SKIPALL, TYP_NONE }, + { NULL } +diff --git a/db/attrshort.c b/db/attrshort.c +index d82559cc..2ef358f5 100644 +--- a/db/attrshort.c ++++ b/db/attrshort.c +@@ -51,10 +51,10 @@ const field_t attr_sf_entry_flds[] = { + { "valuelen", FLDT_UINT8D, OI(EOFF(valuelen)), C1, 0, TYP_NONE }, + { "flags", FLDT_UINT8X, OI(EOFF(flags)), C1, FLD_SKIPALL, TYP_NONE }, + { "root", FLDT_UINT1, +- OI(EOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0, ++ OI(EOFF(flags) + bitsz(uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0, + TYP_NONE }, + { "secure", FLDT_UINT1, +- OI(EOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0, ++ OI(EOFF(flags) + bitsz(uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0, + TYP_NONE }, + { "name", FLDT_CHARNS, OI(EOFF(nameval)), attr_sf_entry_name_count, + FLD_COUNT, TYP_NONE }, +diff --git a/db/bit.c b/db/bit.c +index 24872bf7..f5ebf681 100644 +--- a/db/bit.c ++++ b/db/bit.c +@@ -60,7 +60,7 @@ setbit( + } + } + +-__int64_t ++int64_t + getbitval( + void *obj, + int bitoff, +@@ -70,7 +70,7 @@ getbitval( + int bit; + int i; + char *p; +- __int64_t rval; ++ int64_t rval; + int signext; + int z1, z2, z3, z4; + +diff --git a/db/bit.h b/db/bit.h +index 80ba24c4..9fd71f4b 100644 +--- a/db/bit.h ++++ b/db/bit.h +@@ -25,5 +25,5 @@ + #define BVUNSIGNED 0 + #define BVSIGNED 1 + +-extern __int64_t getbitval(void *obj, int bitoff, int nbits, int flags); ++extern int64_t getbitval(void *obj, int bitoff, int nbits, int flags); + extern void setbitval(void *obuf, int bitoff, int nbits, void *ibuf); +diff --git a/db/block.c b/db/block.c +index 4a357ced..5ecd687a 100644 +--- a/db/block.c ++++ b/db/block.c +@@ -98,7 +98,7 @@ ablock_f( + } + dfsbno = bm.startblock + (bno - bm.startoff); + ASSERT(typtab[TYP_ATTR].typnm == TYP_ATTR); +- set_cur(&typtab[TYP_ATTR], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), ++ set_cur(&typtab[TYP_ATTR], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), + blkbb, DB_RING_ADD, NULL); + return 0; + } +@@ -128,14 +128,14 @@ daddr_f( + int argc, + char **argv) + { +- __int64_t d; ++ int64_t d; + char *p; + + if (argc == 1) { + dbprintf(_("current daddr is %lld\n"), iocur_top->off >> BBSHIFT); + return 0; + } +- d = (__int64_t)strtoull(argv[1], &p, 0); ++ d = (int64_t)strtoull(argv[1], &p, 0); + if (*p != '\0' || + d >= mp->m_sb.sb_dblocks << (mp->m_sb.sb_blocklog - BBSHIFT)) { + dbprintf(_("bad daddr %s\n"), argv[1]); +@@ -197,7 +197,7 @@ dblock_f( + ASSERT(typtab[type].typnm == type); + if (nex > 1) + make_bbmap(&bbmap, nex, bmp); +- set_cur(&typtab[type], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), ++ set_cur(&typtab[type], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), + nb * blkbb, DB_RING_ADD, nex > 1 ? &bbmap : NULL); + free(bmp); + return 0; +diff --git a/db/check.c b/db/check.c +index 8e618a23..81ba63a6 100644 +--- a/db/check.c ++++ b/db/check.c +@@ -114,8 +114,8 @@ typedef struct dirhash { + + static xfs_extlen_t agffreeblks; + static xfs_extlen_t agflongest; +-static __uint64_t agf_aggr_freeblks; /* aggregate count over all */ +-static __uint32_t agfbtreeblks; ++static uint64_t agf_aggr_freeblks; /* aggregate count over all */ ++static uint32_t agfbtreeblks; + static int lazycount; + static xfs_agino_t agicount; + static xfs_agino_t agifreecount; +@@ -124,10 +124,10 @@ static int blist_size; + static char **dbmap; /* really dbm_t:8 */ + static dirhash_t **dirhash; + static int error; +-static __uint64_t fdblocks; +-static __uint64_t frextents; +-static __uint64_t icount; +-static __uint64_t ifree; ++static uint64_t fdblocks; ++static uint64_t frextents; ++static uint64_t icount; ++static uint64_t ifree; + static inodata_t ***inodata; + static int inodata_hash_size; + static inodata_t ***inomap; +@@ -1187,7 +1187,7 @@ blocktrash_f( + goto out; + } + for (i = 0; i < count; i++) { +- randb = (xfs_rfsblock_t)((((__int64_t)random() << 32) | ++ randb = (xfs_rfsblock_t)((((int64_t)random() << 32) | + random()) % blocks); + for (bi = 0, agno = 0, done = 0; + !done && agno < mp->m_sb.sb_agcount; +@@ -3032,7 +3032,7 @@ process_leaf_node_dir_v2( + } + if (v) + dbprintf(_("dir inode %lld block %u=%llu\n"), id->ino, +- (__uint32_t)dbno, ++ (uint32_t)dbno, + (xfs_fsblock_t)bmp->startblock); + push_cur(); + if (nex > 1) +@@ -3045,7 +3045,7 @@ process_leaf_node_dir_v2( + if (!sflag || v) + dbprintf(_("can't read block %u for directory " + "inode %lld\n"), +- (__uint32_t)dbno, id->ino); ++ (uint32_t)dbno, id->ino); + error++; + pop_cur(); + dbno += mp->m_dir_geo->fsbcount - 1; +diff --git a/db/convert.c b/db/convert.c +index a337abea..fa4f9623 100644 +--- a/db/convert.c ++++ b/db/convert.c +@@ -24,13 +24,13 @@ + + #define M(A) (1 << CT_ ## A) + #define agblock_to_bytes(x) \ +- ((__uint64_t)(x) << mp->m_sb.sb_blocklog) ++ ((uint64_t)(x) << mp->m_sb.sb_blocklog) + #define agino_to_bytes(x) \ +- ((__uint64_t)(x) << mp->m_sb.sb_inodelog) ++ ((uint64_t)(x) << mp->m_sb.sb_inodelog) + #define agnumber_to_bytes(x) \ +- agblock_to_bytes((__uint64_t)(x) * mp->m_sb.sb_agblocks) ++ agblock_to_bytes((uint64_t)(x) * mp->m_sb.sb_agblocks) + #define daddr_to_bytes(x) \ +- ((__uint64_t)(x) << BBSHIFT) ++ ((uint64_t)(x) << BBSHIFT) + #define fsblock_to_bytes(x) \ + (agnumber_to_bytes(XFS_FSB_TO_AGNO(mp, (x))) + \ + agblock_to_bytes(XFS_FSB_TO_AGBNO(mp, (x)))) +@@ -38,7 +38,7 @@ + (agnumber_to_bytes(XFS_INO_TO_AGNO(mp, (x))) + \ + agino_to_bytes(XFS_INO_TO_AGINO(mp, (x)))) + #define inoidx_to_bytes(x) \ +- ((__uint64_t)(x) << mp->m_sb.sb_inodelog) ++ ((uint64_t)(x) << mp->m_sb.sb_inodelog) + + typedef enum { + CT_NONE = -1, +@@ -68,7 +68,7 @@ typedef union { + xfs_agnumber_t agnumber; + int bboff; + int blkoff; +- __uint64_t byte; ++ uint64_t byte; + xfs_daddr_t daddr; + xfs_fsblock_t fsblock; + xfs_ino_t ino; +@@ -76,7 +76,7 @@ typedef union { + int inooff; + } cval_t; + +-static __uint64_t bytevalue(ctype_t ctype, cval_t *val); ++static uint64_t bytevalue(ctype_t ctype, cval_t *val); + static int convert_f(int argc, char **argv); + static int getvalue(char *s, ctype_t ctype, cval_t *val); + static ctype_t lookupcty(char *ctyname); +@@ -118,7 +118,7 @@ static const cmdinfo_t convert_cmd = + { "convert", NULL, convert_f, 3, 9, 0, "type num [type num]... type", + "convert from one address form to another", NULL }; + +-static __uint64_t ++static uint64_t + bytevalue(ctype_t ctype, cval_t *val) + { + switch (ctype) { +@@ -129,9 +129,9 @@ bytevalue(ctype_t ctype, cval_t *val) + case CT_AGNUMBER: + return agnumber_to_bytes(val->agnumber); + case CT_BBOFF: +- return (__uint64_t)val->bboff; ++ return (uint64_t)val->bboff; + case CT_BLKOFF: +- return (__uint64_t)val->blkoff; ++ return (uint64_t)val->blkoff; + case CT_BYTE: + return val->byte; + case CT_DADDR: +@@ -143,7 +143,7 @@ bytevalue(ctype_t ctype, cval_t *val) + case CT_INOIDX: + return inoidx_to_bytes(val->inoidx); + case CT_INOOFF: +- return (__uint64_t)val->inooff; ++ return (uint64_t)val->inooff; + case CT_NONE: + case NCTS: + break; +@@ -160,7 +160,7 @@ convert_f(int argc, char **argv) + cval_t cvals[NCTS] = {}; + int i; + int mask; +- __uint64_t v; ++ uint64_t v; + ctype_t wtype; + + /* move past the "convert" command */ +@@ -262,7 +262,7 @@ static int + getvalue(char *s, ctype_t ctype, cval_t *val) + { + char *p; +- __uint64_t v; ++ uint64_t v; + + v = strtoull(s, &p, 0); + if (*p != '\0') { +@@ -286,7 +286,7 @@ getvalue(char *s, ctype_t ctype, cval_t *val) + val->blkoff = (int)v; + break; + case CT_BYTE: +- val->byte = (__uint64_t)v; ++ val->byte = (uint64_t)v; + break; + case CT_DADDR: + val->daddr = (xfs_daddr_t)v; +diff --git a/db/faddr.c b/db/faddr.c +index 877200bf..56207648 100644 +--- a/db/faddr.c ++++ b/db/faddr.c +@@ -79,11 +79,11 @@ fa_attrblock( + typnm_t next) + { + bmap_ext_t bm; +- __uint32_t bno; ++ uint32_t bno; + xfs_fsblock_t dfsbno; + int nex; + +- bno = (__uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED); ++ bno = (uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED); + if (bno == 0) { + dbprintf(_("null attribute block number, cannot set new addr\n")); + return; +@@ -96,7 +96,7 @@ fa_attrblock( + } + dfsbno = bm.startblock + (bno - bm.startoff); + ASSERT(typtab[next].typnm == next); +- set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), blkbb, ++ set_cur(&typtab[next], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), blkbb, + DB_RING_ADD, NULL); + } + +@@ -276,11 +276,11 @@ fa_dirblock( + { + bbmap_t bbmap; + bmap_ext_t *bmp; +- __uint32_t bno; ++ uint32_t bno; + xfs_fsblock_t dfsbno; + int nex; + +- bno = (__uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED); ++ bno = (uint32_t)getbitval(obj, bit, bitsz(bno), BVUNSIGNED); + if (bno == 0) { + dbprintf(_("null directory block number, cannot set new addr\n")); + return; +@@ -297,7 +297,7 @@ fa_dirblock( + ASSERT(typtab[next].typnm == next); + if (nex > 1) + make_bbmap(&bbmap, nex, bmp); +- set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), ++ set_cur(&typtab[next], (int64_t)XFS_FSB_TO_DADDR(mp, dfsbno), + XFS_FSB_TO_BB(mp, mp->m_dir_geo->fsbcount), DB_RING_ADD, + nex > 1 ? &bbmap : NULL); + free(bmp); +@@ -317,7 +317,7 @@ fa_drfsbno( + return; + } + ASSERT(typtab[next].typnm == next); +- set_cur(&typtab[next], (__int64_t)XFS_FSB_TO_BB(mp, bno), blkbb, ++ set_cur(&typtab[next], (int64_t)XFS_FSB_TO_BB(mp, bno), blkbb, + DB_RING_ADD, NULL); + } + +diff --git a/db/field.c b/db/field.c +index 865b0b71..f1e5f35e 100644 +--- a/db/field.c ++++ b/db/field.c +@@ -83,7 +83,7 @@ const ftattr_t ftattrtab[] = { + attr_sf_entry_size, FTARG_SIZE, NULL, attr_sf_entry_flds }, + { FLDT_ATTR_SF_HDR, "attr_sf_hdr", NULL, (char *)attr_sf_hdr_flds, + SI(bitsz(struct xfs_attr_sf_hdr)), 0, NULL, attr_sf_hdr_flds }, +- { FLDT_ATTRBLOCK, "attrblock", fp_num, "%u", SI(bitsz(__uint32_t)), 0, ++ { FLDT_ATTRBLOCK, "attrblock", fp_num, "%u", SI(bitsz(uint32_t)), 0, + fa_attrblock, NULL }, + { FLDT_ATTRSHORT, "attrshort", NULL, (char *)attr_shortform_flds, + attrshort_size, FTARG_SIZE, NULL, attr_shortform_flds }, +@@ -199,7 +199,7 @@ const ftattr_t ftattrtab[] = { + SI(bitsz(struct xfs_refcount_rec)), 0, NULL, refcbt_rec_flds }, + + /* CRC field */ +- { FLDT_CRC, "crc", fp_crc, "%#x (%s)", SI(bitsz(__uint32_t)), ++ { FLDT_CRC, "crc", fp_crc, "%#x (%s)", SI(bitsz(uint32_t)), + 0, NULL, NULL }, + + { FLDT_DEV, "dev", fp_num, "%#x", SI(bitsz(xfs_dev_t)), 0, NULL, NULL }, +@@ -214,7 +214,7 @@ const ftattr_t ftattrtab[] = { + { FLDT_DINODE_CORE, "dinode_core", NULL, (char *)inode_core_flds, + SI(bitsz(xfs_dinode_t)), 0, NULL, inode_core_flds }, + { FLDT_DINODE_FMT, "dinode_fmt", fp_dinode_fmt, NULL, +- SI(bitsz(__int8_t)), 0, NULL, NULL }, ++ SI(bitsz(int8_t)), 0, NULL, NULL }, + { FLDT_DINODE_U, "dinode_u", NULL, (char *)inode_u_flds, inode_u_size, + FTARG_SIZE|FTARG_OKEMPTY, NULL, inode_u_flds }, + { FLDT_DINODE_V3, "dinode_v3", NULL, (char *)inode_v3_flds, +@@ -295,7 +295,7 @@ const ftattr_t ftattrtab[] = { + { FLDT_DA3_NODE_HDR, "dir_node_hdr", NULL, (char *)da3_node_hdr_flds, + SI(bitsz(struct xfs_da3_node_hdr)), 0, NULL, da3_node_hdr_flds }, + +- { FLDT_DIRBLOCK, "dirblock", fp_num, "%u", SI(bitsz(__uint32_t)), 0, ++ { FLDT_DIRBLOCK, "dirblock", fp_num, "%u", SI(bitsz(uint32_t)), 0, + fa_dirblock, NULL }, + { FLDT_DISK_DQUOT, "disk_dquot", NULL, (char *)disk_dquot_flds, + SI(bitsz(xfs_disk_dquot_t)), 0, NULL, disk_dquot_flds }, +@@ -335,15 +335,15 @@ const ftattr_t ftattrtab[] = { + FTARG_SIZE, NULL, inode_crc_flds }, + { FLDT_INOFREE, "inofree", fp_num, "%#llx", SI(bitsz(xfs_inofree_t)), 0, + NULL, NULL }, +- { FLDT_INT16D, "int16d", fp_num, "%d", SI(bitsz(__int16_t)), ++ { FLDT_INT16D, "int16d", fp_num, "%d", SI(bitsz(int16_t)), + FTARG_SIGNED, NULL, NULL }, +- { FLDT_INT32D, "int32d", fp_num, "%d", SI(bitsz(__int32_t)), ++ { FLDT_INT32D, "int32d", fp_num, "%d", SI(bitsz(int32_t)), + FTARG_SIGNED, NULL, NULL }, +- { FLDT_INT64D, "int64d", fp_num, "%lld", SI(bitsz(__int64_t)), ++ { FLDT_INT64D, "int64d", fp_num, "%lld", SI(bitsz(int64_t)), + FTARG_SIGNED, NULL, NULL }, +- { FLDT_INT8D, "int8d", fp_num, "%d", SI(bitsz(__int8_t)), FTARG_SIGNED, ++ { FLDT_INT8D, "int8d", fp_num, "%d", SI(bitsz(int8_t)), FTARG_SIGNED, + NULL, NULL }, +- { FLDT_NSEC, "nsec", fp_num, "%09d", SI(bitsz(__int32_t)), FTARG_SIGNED, ++ { FLDT_NSEC, "nsec", fp_num, "%09d", SI(bitsz(int32_t)), FTARG_SIGNED, + NULL, NULL }, + { FLDT_QCNT, "qcnt", fp_num, "%llu", SI(bitsz(xfs_qcnt_t)), 0, NULL, + NULL }, +@@ -356,34 +356,34 @@ const ftattr_t ftattrtab[] = { + { FLDT_SYMLINK_CRC, "symlink", NULL, (char *)symlink_crc_flds, + symlink_size, FTARG_SIZE, NULL, symlink_crc_flds }, + +- { FLDT_TIME, "time", fp_time, NULL, SI(bitsz(__int32_t)), FTARG_SIGNED, ++ { FLDT_TIME, "time", fp_time, NULL, SI(bitsz(int32_t)), FTARG_SIGNED, + NULL, NULL }, + { FLDT_TIMESTAMP, "timestamp", NULL, (char *)timestamp_flds, + SI(bitsz(xfs_timestamp_t)), 0, NULL, timestamp_flds }, + { FLDT_UINT1, "uint1", fp_num, "%u", SI(1), 0, NULL, NULL }, +- { FLDT_UINT16D, "uint16d", fp_num, "%u", SI(bitsz(__uint16_t)), 0, NULL, ++ { FLDT_UINT16D, "uint16d", fp_num, "%u", SI(bitsz(uint16_t)), 0, NULL, + NULL }, +- { FLDT_UINT16O, "uint16o", fp_num, "%#o", SI(bitsz(__uint16_t)), 0, ++ { FLDT_UINT16O, "uint16o", fp_num, "%#o", SI(bitsz(uint16_t)), 0, + NULL, NULL }, +- { FLDT_UINT16X, "uint16x", fp_num, "%#x", SI(bitsz(__uint16_t)), 0, ++ { FLDT_UINT16X, "uint16x", fp_num, "%#x", SI(bitsz(uint16_t)), 0, + NULL, NULL }, +- { FLDT_UINT32D, "uint32d", fp_num, "%u", SI(bitsz(__uint32_t)), 0, NULL, ++ { FLDT_UINT32D, "uint32d", fp_num, "%u", SI(bitsz(uint32_t)), 0, NULL, + NULL }, +- { FLDT_UINT32O, "uint32o", fp_num, "%#o", SI(bitsz(__uint32_t)), 0, ++ { FLDT_UINT32O, "uint32o", fp_num, "%#o", SI(bitsz(uint32_t)), 0, + NULL, NULL }, +- { FLDT_UINT32X, "uint32x", fp_num, "%#x", SI(bitsz(__uint32_t)), 0, ++ { FLDT_UINT32X, "uint32x", fp_num, "%#x", SI(bitsz(uint32_t)), 0, + NULL, NULL }, +- { FLDT_UINT64D, "uint64d", fp_num, "%llu", SI(bitsz(__uint64_t)), 0, ++ { FLDT_UINT64D, "uint64d", fp_num, "%llu", SI(bitsz(uint64_t)), 0, + NULL, NULL }, +- { FLDT_UINT64O, "uint64o", fp_num, "%#llo", SI(bitsz(__uint64_t)), 0, ++ { FLDT_UINT64O, "uint64o", fp_num, "%#llo", SI(bitsz(uint64_t)), 0, + NULL, NULL }, +- { FLDT_UINT64X, "uint64x", fp_num, "%#llx", SI(bitsz(__uint64_t)), 0, ++ { FLDT_UINT64X, "uint64x", fp_num, "%#llx", SI(bitsz(uint64_t)), 0, + NULL, NULL }, +- { FLDT_UINT8D, "uint8d", fp_num, "%u", SI(bitsz(__uint8_t)), 0, NULL, ++ { FLDT_UINT8D, "uint8d", fp_num, "%u", SI(bitsz(uint8_t)), 0, NULL, + NULL }, +- { FLDT_UINT8O, "uint8o", fp_num, "%#o", SI(bitsz(__uint8_t)), 0, NULL, ++ { FLDT_UINT8O, "uint8o", fp_num, "%#o", SI(bitsz(uint8_t)), 0, NULL, + NULL }, +- { FLDT_UINT8X, "uint8x", fp_num, "%#x", SI(bitsz(__uint8_t)), 0, NULL, ++ { FLDT_UINT8X, "uint8x", fp_num, "%#x", SI(bitsz(uint8_t)), 0, NULL, + NULL }, + { FLDT_UUID, "uuid", fp_uuid, NULL, SI(bitsz(uuid_t)), 0, NULL, NULL }, + { FLDT_ZZZ, NULL } +diff --git a/db/fprint.c b/db/fprint.c +index fd7e7f45..261a31ef 100644 +--- a/db/fprint.c ++++ b/db/fprint.c +@@ -80,7 +80,7 @@ fp_num( + int bitpos; + int i; + int isnull; +- __int64_t val; ++ int64_t val; + + for (i = 0, bitpos = bit; + i < count && !seenint(); +@@ -100,7 +100,7 @@ fp_num( + else if (size > 32) + dbprintf(fmtstr, val); + else +- dbprintf(fmtstr, (__int32_t)val); ++ dbprintf(fmtstr, (int32_t)val); + if (i < count - 1) + dbprintf(" "); + } +@@ -203,7 +203,7 @@ fp_crc( + { + int bitpos; + int i; +- __int64_t val; ++ int64_t val; + char *ok; + + switch (iocur_crc_valid()) { +@@ -230,7 +230,7 @@ fp_crc( + if (size > 32) + dbprintf(fmtstr, val, ok); + else +- dbprintf(fmtstr, (__int32_t)val, ok); ++ dbprintf(fmtstr, (int32_t)val, ok); + if (i < count - 1) + dbprintf(" "); + } +diff --git a/db/frag.c b/db/frag.c +index 8005e45d..d224f0c2 100644 +--- a/db/frag.c ++++ b/db/frag.c +@@ -42,8 +42,8 @@ typedef struct extmap { + + static int aflag; + static int dflag; +-static __uint64_t extcount_actual; +-static __uint64_t extcount_ideal; ++static uint64_t extcount_actual; ++static uint64_t extcount_ideal; + static int fflag; + static int lflag; + static int qflag; +@@ -310,8 +310,8 @@ process_inode( + xfs_agino_t agino, + xfs_dinode_t *dip) + { +- __uint64_t actual; +- __uint64_t ideal; ++ uint64_t actual; ++ uint64_t ideal; + xfs_ino_t ino; + int skipa; + int skipd; +diff --git a/db/inode.c b/db/inode.c +index 8b7a41e4..6cc47d6a 100644 +--- a/db/inode.c ++++ b/db/inode.c +@@ -119,49 +119,49 @@ const field_t inode_core_flds[] = { + { "dmstate", FLDT_UINT16D, OI(COFF(dmstate)), C1, 0, TYP_NONE }, + { "flags", FLDT_UINT16X, OI(COFF(flags)), C1, FLD_SKIPALL, TYP_NONE }, + { "newrtbm", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NEWRTBM_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NEWRTBM_BIT - 1), C1, + 0, TYP_NONE }, + { "prealloc", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_PREALLOC_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_PREALLOC_BIT - 1), C1, + 0, TYP_NONE }, + { "realtime", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_REALTIME_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_REALTIME_BIT - 1), C1, + 0, TYP_NONE }, + { "immutable", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_IMMUTABLE_BIT-1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_IMMUTABLE_BIT-1), C1, + 0, TYP_NONE }, + { "append", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_APPEND_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_APPEND_BIT - 1), C1, + 0, TYP_NONE }, + { "sync", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_SYNC_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_SYNC_BIT - 1), C1, + 0, TYP_NONE }, + { "noatime", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NOATIME_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NOATIME_BIT - 1), C1, + 0, TYP_NONE }, + { "nodump", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NODUMP_BIT - 1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NODUMP_BIT - 1), C1, + 0, TYP_NONE }, + { "rtinherit", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_RTINHERIT_BIT-1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_RTINHERIT_BIT-1), C1, + 0, TYP_NONE }, + { "projinherit", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_PROJINHERIT_BIT-1),C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_PROJINHERIT_BIT-1), C1, + 0, TYP_NONE }, + { "nosymlinks", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NOSYMLINKS_BIT-1), C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NOSYMLINKS_BIT-1), C1, + 0, TYP_NONE }, + { "extsz", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_EXTSIZE_BIT-1),C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_EXTSIZE_BIT-1), C1, + 0, TYP_NONE }, + { "extszinherit", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_EXTSZINHERIT_BIT-1),C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_EXTSZINHERIT_BIT-1), C1, + 0, TYP_NONE }, + { "nodefrag", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NODEFRAG_BIT-1),C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_NODEFRAG_BIT-1), C1, + 0, TYP_NONE }, + { "filestream", FLDT_UINT1, +- OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_FILESTREAM_BIT-1),C1, ++ OI(COFF(flags) + bitsz(uint16_t) - XFS_DIFLAG_FILESTREAM_BIT-1), C1, + 0, TYP_NONE }, + { "gen", FLDT_UINT32D, OI(COFF(gen)), C1, 0, TYP_NONE }, + { NULL } +@@ -177,10 +177,10 @@ const field_t inode_v3_flds[] = { + { "inumber", FLDT_INO, OI(COFF(ino)), C1, 0, TYP_NONE }, + { "uuid", FLDT_UUID, OI(COFF(uuid)), C1, 0, TYP_NONE }, + { "reflink", FLDT_UINT1, +- OI(COFF(flags2) + bitsz(__uint64_t) - XFS_DIFLAG2_REFLINK_BIT-1), C1, ++ OI(COFF(flags2) + bitsz(uint64_t) - XFS_DIFLAG2_REFLINK_BIT-1), C1, + 0, TYP_NONE }, + { "cowextsz", FLDT_UINT1, +- OI(COFF(flags2) + bitsz(__uint64_t) - XFS_DIFLAG2_COWEXTSIZE_BIT-1), C1, ++ OI(COFF(flags2) + bitsz(uint64_t) - XFS_DIFLAG2_COWEXTSIZE_BIT-1), C1, + 0, TYP_NONE }, + { NULL } + }; +diff --git a/db/io.c b/db/io.c +index 1f27f6b3..fd9b9f4b 100644 +--- a/db/io.c ++++ b/db/io.c +@@ -545,7 +545,7 @@ set_cur( + struct xfs_buf *bp; + xfs_ino_t dirino; + xfs_ino_t ino; +- __uint16_t mode; ++ uint16_t mode; + const struct xfs_buf_ops *ops = type ? type->bops : NULL; + + if (iocur_sp < 0) { +diff --git a/db/io.h b/db/io.h +index 99730048..df0fdd75 100644 +--- a/db/io.h ++++ b/db/io.h +@@ -25,7 +25,7 @@ typedef struct bbmap { + } bbmap_t; + + typedef struct iocur { +- __int64_t bb; /* BB number in filesystem of buf */ ++ int64_t bb; /* BB number in filesystem of buf */ + int blen; /* length of "buf", bb's */ + int boff; /* data - buf */ + void *buf; /* base address of buffer */ +@@ -33,7 +33,7 @@ typedef struct iocur { + xfs_ino_t dirino; /* current directory inode number */ + xfs_ino_t ino; /* current inode number */ + int len; /* length of "data", bytes */ +- __uint16_t mode; /* current inode's mode */ ++ uint16_t mode; /* current inode's mode */ + xfs_off_t off; /* fs offset of "data" in bytes */ + const struct typ *typ; /* type of "data" */ + bbmap_t *bbmap; /* map daddr if fragmented */ +@@ -57,7 +57,7 @@ extern void off_cur(int off, int len); + extern void pop_cur(void); + extern void print_iocur(char *tag, iocur_t *ioc); + extern void push_cur(void); +-extern int read_buf(__int64_t daddr, int count, void *bufp); ++extern int read_buf(int64_t daddr, int count, void *bufp); + extern void write_cur(void); + extern void set_cur(const struct typ *type, xfs_daddr_t blknum, + int len, int ring_add, bbmap_t *bbmap); +diff --git a/db/metadump.c b/db/metadump.c +index 31bb5959..67bdf14e 100644 +--- a/db/metadump.c ++++ b/db/metadump.c +@@ -175,7 +175,7 @@ write_index(void) + static int + write_buf_segment( + char *data, +- __int64_t off, ++ int64_t off, + int len) + { + int i; +@@ -1256,7 +1256,7 @@ process_sf_dir( + { + struct xfs_dir2_sf_hdr *sfp; + xfs_dir2_sf_entry_t *sfep; +- __uint64_t ino_dir_size; ++ uint64_t ino_dir_size; + int i; + + sfp = (struct xfs_dir2_sf_hdr *)XFS_DFORK_DPTR(dip); +@@ -1322,7 +1322,7 @@ process_sf_dir( + static void + obfuscate_path_components( + char *buf, +- __uint64_t len) ++ uint64_t len) + { + unsigned char *comp = (unsigned char *)buf; + unsigned char *end = comp + len; +@@ -1359,7 +1359,7 @@ static void + process_sf_symlink( + xfs_dinode_t *dip) + { +- __uint64_t len; ++ uint64_t len; + char *buf; + + len = be64_to_cpu(dip->di_size); +@@ -1631,7 +1631,7 @@ process_attr_block( + xfs_attr_leaf_entry_t *entry; + xfs_attr_leaf_name_local_t *local; + xfs_attr_leaf_name_remote_t *remote; +- __uint32_t bs = mp->m_sb.sb_blocksize; ++ uint32_t bs = mp->m_sb.sb_blocksize; + char *first_name; + + +@@ -2270,7 +2270,7 @@ done: + return success; + } + +-static __uint32_t inodes_copied = 0; ++static uint32_t inodes_copied; + + static int + copy_inode_chunk( +diff --git a/db/sb.c b/db/sb.c +index 8e7722cd..f19248d7 100644 +--- a/db/sb.c ++++ b/db/sb.c +@@ -606,7 +606,7 @@ version_help(void) + } + + static int +-do_version(xfs_agnumber_t agno, __uint16_t version, __uint32_t features) ++do_version(xfs_agnumber_t agno, uint16_t version, uint32_t features) + { + xfs_sb_t tsb; + +@@ -710,8 +710,8 @@ version_f( + int argc, + char **argv) + { +- __uint16_t version = 0; +- __uint32_t features = 0; ++ uint16_t version = 0; ++ uint32_t features = 0; + xfs_agnumber_t ag; + + if (argc == 2) { /* WRITE VERSION */ +diff --git a/fsr/xfs_fsr.c b/fsr/xfs_fsr.c +index 517b75f0..d4846a32 100644 +--- a/fsr/xfs_fsr.c ++++ b/fsr/xfs_fsr.c +@@ -54,7 +54,7 @@ struct getbmap *outmap = NULL; + int outmap_size = 0; + int RealUid; + int tmp_agi; +-static __int64_t minimumfree = 2048; ++static int64_t minimumfree = 2048; + + #define MNTTYPE_XFS "xfs" + +diff --git a/include/darwin.h b/include/darwin.h +index 7bbd5764..51031c42 100644 +--- a/include/darwin.h ++++ b/include/darwin.h +@@ -125,15 +125,15 @@ typedef signed int __s32; + typedef unsigned long long int __u64; + typedef signed long long int __s64; + +-#define __int8_t int8_t +-#define __int16_t int16_t +-#define __int32_t int32_t +-#define __int32_t int32_t +-#define __int64_t int64_t +-#define __uint8_t u_int8_t +-#define __uint16_t u_int16_t +-#define __uint32_t u_int32_t +-#define __uint64_t u_int64_t ++#define int8_t int8_t ++#define int16_t int16_t ++#define int32_t int32_t ++#define int32_t int32_t ++#define int64_t int64_t ++#define uint8_t u_int8_t ++#define uint16_t u_int16_t ++#define uint32_t u_int32_t ++#define uint64_t u_int64_t + + typedef off_t xfs_off_t; + typedef u_int64_t xfs_ino_t; +diff --git a/include/freebsd.h b/include/freebsd.h +index fb318b89..f52ed0a9 100644 +--- a/include/freebsd.h ++++ b/include/freebsd.h +@@ -50,9 +50,9 @@ typedef unsigned long long int __u64; + typedef signed long long int __s64; + + typedef off_t xfs_off_t; +-typedef __uint64_t xfs_ino_t; +-typedef __uint32_t xfs_dev_t; +-typedef __int64_t xfs_daddr_t; ++typedef uint64_t xfs_ino_t; ++typedef uint32_t xfs_dev_t; ++typedef int64_t xfs_daddr_t; + typedef __u32 xfs_nlink_t; + + #define O_LARGEFILE 0 +diff --git a/include/gnukfreebsd.h b/include/gnukfreebsd.h +index 6916e65a..1db3f4f0 100644 +--- a/include/gnukfreebsd.h ++++ b/include/gnukfreebsd.h +@@ -46,9 +46,9 @@ typedef unsigned long long int __u64; + typedef signed long long int __s64; + + typedef off_t xfs_off_t; +-typedef __uint64_t xfs_ino_t; +-typedef __uint32_t xfs_dev_t; +-typedef __int64_t xfs_daddr_t; ++typedef uint64_t xfs_ino_t; ++typedef uint32_t xfs_dev_t; ++typedef int64_t xfs_daddr_t; + typedef __u32 xfs_nlink_t; + + #define HAVE_FID 1 +diff --git a/include/libxcmd.h b/include/libxcmd.h +index e8d2ffc8..6806380c 100644 +--- a/include/libxcmd.h ++++ b/include/libxcmd.h +@@ -42,10 +42,10 @@ get_topology( + extern void + calc_default_ag_geometry( + int blocklog, +- __uint64_t dblocks, ++ uint64_t dblocks, + int multidisk, +- __uint64_t *agsize, +- __uint64_t *agcount); ++ uint64_t *agsize, ++ uint64_t *agcount); + + extern int + check_overwrite( +diff --git a/include/linux.h b/include/linux.h +index 9611a37f..6ce344c5 100644 +--- a/include/linux.h ++++ b/include/linux.h +@@ -132,7 +132,7 @@ static __inline__ void platform_uuid_copy(uuid_t *dst, uuid_t *src) + static __inline__ int + platform_discard_blocks(int fd, uint64_t start, uint64_t len) + { +- __uint64_t range[2] = { start, len }; ++ uint64_t range[2] = { start, len }; + + if (ioctl(fd, BLKDISCARD, &range) < 0) + return errno; +@@ -144,9 +144,9 @@ platform_discard_blocks(int fd, uint64_t start, uint64_t len) + #define EFSBADCRC EBADMSG /* Bad CRC detected */ + + typedef off_t xfs_off_t; +-typedef __uint64_t xfs_ino_t; +-typedef __uint32_t xfs_dev_t; +-typedef __int64_t xfs_daddr_t; ++typedef uint64_t xfs_ino_t; ++typedef uint32_t xfs_dev_t; ++typedef int64_t xfs_daddr_t; + typedef __u32 xfs_nlink_t; + + /** +diff --git a/include/xfs_arch.h b/include/xfs_arch.h +index 12cd43e6..186cadba 100644 +--- a/include/xfs_arch.h ++++ b/include/xfs_arch.h +@@ -244,39 +244,39 @@ static inline void be64_add_cpu(__be64 *a, __s64 b) + *a = cpu_to_be64(be64_to_cpu(*a) + b); + } + +-static inline __uint16_t get_unaligned_be16(void *p) ++static inline uint16_t get_unaligned_be16(void *p) + { +- __uint8_t *__p = p; ++ uint8_t *__p = p; + return __p[0] << 8 | __p[1]; + } + +-static inline __uint32_t get_unaligned_be32(void *p) ++static inline uint32_t get_unaligned_be32(void *p) + { +- __uint8_t *__p = p; ++ uint8_t *__p = p; + return __p[0] << 24 | __p[1] << 16 | __p[2] << 8 | __p[3]; + } + +-static inline __uint64_t get_unaligned_be64(void *p) ++static inline uint64_t get_unaligned_be64(void *p) + { +- return (__uint64_t)get_unaligned_be32(p) << 32 | ++ return (uint64_t)get_unaligned_be32(p) << 32 | + get_unaligned_be32(p + 4); + } + +-static inline void put_unaligned_be16(__uint16_t val, void *p) ++static inline void put_unaligned_be16(uint16_t val, void *p) + { +- __uint8_t *__p = p; ++ uint8_t *__p = p; + *__p++ = val >> 8; + *__p++ = val; + } + +-static inline void put_unaligned_be32(__uint32_t val, void *p) ++static inline void put_unaligned_be32(uint32_t val, void *p) + { +- __uint8_t *__p = p; ++ uint8_t *__p = p; + put_unaligned_be16(val >> 16, __p); + put_unaligned_be16(val, __p + 2); + } + +-static inline void put_unaligned_be64(__uint64_t val, void *p) ++static inline void put_unaligned_be64(uint64_t val, void *p) + { + put_unaligned_be32(val >> 32, p); + put_unaligned_be32(val, p + 4); +diff --git a/include/xfs_inode.h b/include/xfs_inode.h +index fb6b5429..8766024e 100644 +--- a/include/xfs_inode.h ++++ b/include/xfs_inode.h +@@ -123,8 +123,8 @@ xfs_get_projid(struct xfs_icdinode *id) + static inline void + xfs_set_projid(struct xfs_icdinode *id, prid_t projid) + { +- id->di_projid_hi = (__uint16_t) (projid >> 16); +- id->di_projid_lo = (__uint16_t) (projid & 0xffff); ++ id->di_projid_hi = (uint16_t) (projid >> 16); ++ id->di_projid_lo = (uint16_t) (projid & 0xffff); + } + + static inline bool xfs_is_reflink_inode(struct xfs_inode *ip) +diff --git a/include/xfs_log_recover.h b/include/xfs_log_recover.h +index 7582676b..0d098628 100644 +--- a/include/xfs_log_recover.h ++++ b/include/xfs_log_recover.h +@@ -26,7 +26,7 @@ + #define XLOG_RHASH_SIZE 16 + #define XLOG_RHASH_SHIFT 2 + #define XLOG_RHASH(tid) \ +- ((((__uint32_t)tid)>>XLOG_RHASH_SHIFT) & (XLOG_RHASH_SIZE-1)) ++ ((((uint32_t)tid)>>XLOG_RHASH_SHIFT) & (XLOG_RHASH_SIZE-1)) + + #define XLOG_MAX_REGIONS_IN_ITEM (XFS_MAX_BLOCKSIZE / XFS_BLF_CHUNK / 2 + 1) + +diff --git a/include/xfs_metadump.h b/include/xfs_metadump.h +index 7f3039eb..13afb8dd 100644 +--- a/include/xfs_metadump.h ++++ b/include/xfs_metadump.h +@@ -24,8 +24,8 @@ + typedef struct xfs_metablock { + __be32 mb_magic; + __be16 mb_count; +- __uint8_t mb_blocklog; +- __uint8_t mb_info; ++ uint8_t mb_blocklog; ++ uint8_t mb_info; + /* followed by an array of xfs_daddr_t */ + } xfs_metablock_t; + +diff --git a/include/xfs_mount.h b/include/xfs_mount.h +index 5ff24ebf..5b323bb1 100644 +--- a/include/xfs_mount.h ++++ b/include/xfs_mount.h +@@ -48,12 +48,12 @@ typedef struct xfs_mount { + #define m_dev m_ddev_targp + #define m_logdev m_logdev_targp + #define m_rtdev m_rtdev_targp +- __uint8_t m_dircook_elog; /* log d-cookie entry bits */ +- __uint8_t m_blkbit_log; /* blocklog + NBBY */ +- __uint8_t m_blkbb_log; /* blocklog - BBSHIFT */ +- __uint8_t m_sectbb_log; /* sectorlog - BBSHIFT */ +- __uint8_t m_agno_log; /* log #ag's */ +- __uint8_t m_agino_log; /* #bits for agino in inum */ ++ uint8_t m_dircook_elog; /* log d-cookie entry bits */ ++ uint8_t m_blkbit_log; /* blocklog + NBBY */ ++ uint8_t m_blkbb_log; /* blocklog - BBSHIFT */ ++ uint8_t m_sectbb_log; /* sectorlog - BBSHIFT */ ++ uint8_t m_agno_log; /* log #ag's */ ++ uint8_t m_agino_log; /* #bits for agino in inum */ + uint m_inode_cluster_size;/* min inode buf size */ + uint m_blockmask; /* sb_blocksize-1 */ + uint m_blockwsize; /* sb_blocksize in words */ +@@ -88,7 +88,7 @@ typedef struct xfs_mount { + int m_litino; /* size of inode union area */ + int m_inoalign_mask;/* mask sb_inoalignmt if used */ + struct xfs_trans_resv m_resv; /* precomputed res values */ +- __uint64_t m_maxicount; /* maximum inode count */ ++ uint64_t m_maxicount; /* maximum inode count */ + int m_dalign; /* stripe unit */ + int m_swidth; /* stripe width */ + int m_sinoalign; /* stripe unit inode alignmnt */ +@@ -144,12 +144,12 @@ typedef struct xfs_perag { + char pagi_init; /* this agi's entry is initialized */ + char pagf_metadata; /* the agf is preferred to be metadata */ + char pagi_inodeok; /* The agi is ok for inodes */ +- __uint8_t pagf_levels[XFS_BTNUM_AGF]; ++ uint8_t pagf_levels[XFS_BTNUM_AGF]; + /* # of levels in bno & cnt btree */ +- __uint32_t pagf_flcount; /* count of blocks in freelist */ ++ uint32_t pagf_flcount; /* count of blocks in freelist */ + xfs_extlen_t pagf_freeblks; /* total free blocks */ + xfs_extlen_t pagf_longest; /* longest free space */ +- __uint32_t pagf_btreeblks; /* # of blocks held in AGF btrees */ ++ uint32_t pagf_btreeblks; /* # of blocks held in AGF btrees */ + xfs_agino_t pagi_freecount; /* number of free inodes */ + xfs_agino_t pagi_count; /* number of allocated inodes */ + +@@ -169,7 +169,7 @@ typedef struct xfs_perag { + struct xfs_ag_resv pag_agfl_resv; + + /* reference count */ +- __uint8_t pagf_refcount_level; ++ uint8_t pagf_refcount_level; + } xfs_perag_t; + + static inline struct xfs_ag_resv * +diff --git a/libhandle/handle.c b/libhandle/handle.c +index 236ed22a..00127b3c 100644 +--- a/libhandle/handle.c ++++ b/libhandle/handle.c +@@ -232,7 +232,7 @@ obj_to_handle( + { + char hbuf [MAXHANSIZ]; + int ret; +- __uint32_t handlen; ++ uint32_t handlen; + xfs_fsop_handlereq_t hreq; + + if (opcode == XFS_IOC_FD_TO_HANDLE) { +diff --git a/libhandle/jdm.c b/libhandle/jdm.c +index e52f5d83..821061b4 100644 +--- a/libhandle/jdm.c ++++ b/libhandle/jdm.c +@@ -36,7 +36,7 @@ typedef struct filehandle { + fshandle_t fh_fshandle; /* handle of fs containing this inode */ + int16_t fh_sz_following; /* bytes in handle after this member */ + char fh_pad[FILEHANDLE_SZ_PAD]; /* padding, must be zeroed */ +- __uint32_t fh_gen; /* generation count */ ++ uint32_t fh_gen; /* generation count */ + xfs_ino_t fh_ino; /* 64 bit ino */ + } filehandle_t; + +diff --git a/libxcmd/topology.c b/libxcmd/topology.c +index 8b0276a7..f66dd1bc 100644 +--- a/libxcmd/topology.c ++++ b/libxcmd/topology.c +@@ -23,19 +23,19 @@ + #endif /* ENABLE_BLKID */ + #include "xfs_multidisk.h" + +-#define TERABYTES(count, blog) ((__uint64_t)(count) << (40 - (blog))) +-#define GIGABYTES(count, blog) ((__uint64_t)(count) << (30 - (blog))) +-#define MEGABYTES(count, blog) ((__uint64_t)(count) << (20 - (blog))) ++#define TERABYTES(count, blog) ((uint64_t)(count) << (40 - (blog))) ++#define GIGABYTES(count, blog) ((uint64_t)(count) << (30 - (blog))) ++#define MEGABYTES(count, blog) ((uint64_t)(count) << (20 - (blog))) + + void + calc_default_ag_geometry( + int blocklog, +- __uint64_t dblocks, ++ uint64_t dblocks, + int multidisk, +- __uint64_t *agsize, +- __uint64_t *agcount) ++ uint64_t *agsize, ++ uint64_t *agcount) + { +- __uint64_t blocks = 0; ++ uint64_t blocks = 0; + int shift = 0; + + /* +diff --git a/libxfs/darwin.c b/libxfs/darwin.c +index 74507e81..16d2c35c 100644 +--- a/libxfs/darwin.c ++++ b/libxfs/darwin.c +@@ -68,7 +68,7 @@ platform_flush_device(int fd, dev_t device) + void + platform_findsizes(char *path, int fd, long long *sz, int *bsz) + { +- __uint64_t size; ++ uint64_t size; + struct stat st; + + if (fstat(fd, &st) < 0) { +diff --git a/libxfs/freebsd.c b/libxfs/freebsd.c +index 4667d1f5..d7bca142 100644 +--- a/libxfs/freebsd.c ++++ b/libxfs/freebsd.c +@@ -109,7 +109,7 @@ void + platform_findsizes(char *path, int fd, long long *sz, int *bsz) + { + struct stat st; +- __int64_t size; ++ int64_t size; + u_int ssize; + + if (fstat(fd, &st) < 0) { +diff --git a/libxfs/init.c b/libxfs/init.c +index fc14c5e4..0f41a853 100644 +--- a/libxfs/init.c ++++ b/libxfs/init.c +@@ -546,7 +546,7 @@ libxfs_initialize_perag( + * the max inode percentage. + */ + if (mp->m_maxicount) { +- __uint64_t icount; ++ uint64_t icount; + + icount = sbp->sb_dblocks * sbp->sb_imax_pct; + do_div(icount, 100); +diff --git a/libxfs/irix.c b/libxfs/irix.c +index 32fcb3e5..0f14aec7 100644 +--- a/libxfs/irix.c ++++ b/libxfs/irix.c +@@ -22,7 +22,7 @@ + + int platform_has_uuid = 0; + extern char *progname; +-extern __int64_t findsize(char *); ++extern int64_t findsize(char *); + + int + platform_check_ismounted(char *name, char *block, struct stat *s, int verbose) +diff --git a/libxfs/libxfs_priv.h b/libxfs/libxfs_priv.h +index b4f766db..d525b667 100644 +--- a/libxfs/libxfs_priv.h ++++ b/libxfs/libxfs_priv.h +@@ -296,8 +296,8 @@ roundup_pow_of_two(uint v) + return 0; + } + +-static inline __uint64_t +-roundup_64(__uint64_t x, __uint32_t y) ++static inline uint64_t ++roundup_64(uint64_t x, uint32_t y) + { + x += y - 1; + do_div(x, y); +diff --git a/libxfs/linux.c b/libxfs/linux.c +index 69f04ad9..0bace3eb 100644 +--- a/libxfs/linux.c ++++ b/libxfs/linux.c +@@ -163,7 +163,7 @@ void + platform_findsizes(char *path, int fd, long long *sz, int *bsz) + { + struct stat st; +- __uint64_t size; ++ uint64_t size; + int error; + + if (fstat(fd, &st) < 0) { +diff --git a/libxfs/logitem.c b/libxfs/logitem.c +index 7e93f609..466b4421 100644 +--- a/libxfs/logitem.c ++++ b/libxfs/logitem.c +@@ -121,7 +121,7 @@ xfs_buf_item_init( + bip->bli_item.li_mountp = mp; + bip->bli_buf = bp; + bip->bli_format.blf_type = XFS_LI_BUF; +- bip->bli_format.blf_blkno = (__int64_t)XFS_BUF_ADDR(bp); ++ bip->bli_format.blf_blkno = (int64_t)XFS_BUF_ADDR(bp); + bip->bli_format.blf_len = (unsigned short)BTOBB(XFS_BUF_COUNT(bp)); + XFS_BUF_SET_FSPRIVATE(bp, bip); + } +diff --git a/libxfs/radix-tree.c b/libxfs/radix-tree.c +index eef9c36d..3f0257fe 100644 +--- a/libxfs/radix-tree.c ++++ b/libxfs/radix-tree.c +@@ -66,21 +66,21 @@ static unsigned long height_to_maxindex[RADIX_TREE_MAX_PATH]; + static inline void tag_set(struct radix_tree_node *node, unsigned int tag, + int offset) + { +- *((__uint32_t *)node->tags[tag] + (offset >> 5)) |= (1 << (offset & 31)); ++ *((uint32_t *)node->tags[tag] + (offset >> 5)) |= (1 << (offset & 31)); + } + + static inline void tag_clear(struct radix_tree_node *node, unsigned int tag, + int offset) + { +- __uint32_t *p = (__uint32_t*)node->tags[tag] + (offset >> 5); +- __uint32_t m = 1 << (offset & 31); ++ uint32_t *p = (uint32_t*)node->tags[tag] + (offset >> 5); ++ uint32_t m = 1 << (offset & 31); + *p &= ~m; + } + + static inline int tag_get(struct radix_tree_node *node, unsigned int tag, + int offset) + { +- return 1 & (((const __uint32_t *)node->tags[tag])[offset >> 5] >> (offset & 31)); ++ return 1 & (((const uint32_t *)node->tags[tag])[offset >> 5] >> (offset & 31)); + } + + /* +diff --git a/libxfs/rdwr.c b/libxfs/rdwr.c +index 21c42f14..474e5ebc 100644 +--- a/libxfs/rdwr.c ++++ b/libxfs/rdwr.c +@@ -118,9 +118,9 @@ static void unmount_record(void *p) + xlog_op_header_t *op = (xlog_op_header_t *)p; + /* the data section must be 32 bit size aligned */ + struct { +- __uint16_t magic; +- __uint16_t pad1; +- __uint32_t pad2; /* may as well make it 64 bits */ ++ uint16_t magic; ++ uint16_t pad1; ++ uint32_t pad2; /* may as well make it 64 bits */ + } magic = { XLOG_UNMOUNT_TYPE, 0, 0 }; + + memset(p, 0, BBSIZE); +diff --git a/libxfs/util.c b/libxfs/util.c +index dcfca397..7938e317 100644 +--- a/libxfs/util.c ++++ b/libxfs/util.c +@@ -170,8 +170,8 @@ libxfs_trans_ichgtime( + if (flags & XFS_ICHGTIME_CHG) + VFS_I(ip)->i_ctime = tv; + if (flags & XFS_ICHGTIME_CREATE) { +- ip->i_d.di_crtime.t_sec = (__int32_t)tv.tv_sec; +- ip->i_d.di_crtime.t_nsec = (__int32_t)tv.tv_nsec; ++ ip->i_d.di_crtime.t_sec = (int32_t)tv.tv_sec; ++ ip->i_d.di_crtime.t_nsec = (int32_t)tv.tv_nsec; + } + } + +@@ -261,8 +261,8 @@ libxfs_ialloc( + ASSERT(uuid_equal(&ip->i_d.di_uuid, &mp->m_sb.sb_meta_uuid)); + VFS_I(ip)->i_version = 1; + ip->i_d.di_flags2 = 0; +- ip->i_d.di_crtime.t_sec = (__int32_t)VFS_I(ip)->i_mtime.tv_sec; +- ip->i_d.di_crtime.t_nsec = (__int32_t)VFS_I(ip)->i_mtime.tv_nsec; ++ ip->i_d.di_crtime.t_sec = (int32_t)VFS_I(ip)->i_mtime.tv_sec; ++ ip->i_d.di_crtime.t_nsec = (int32_t)VFS_I(ip)->i_mtime.tv_nsec; + } + + flags = XFS_ILOG_CORE; +diff --git a/logprint/log_misc.c b/logprint/log_misc.c +index 0dfcfd19..2fd01ceb 100644 +--- a/logprint/log_misc.c ++++ b/logprint/log_misc.c +@@ -166,12 +166,12 @@ xlog_print_trans_header(char **ptr, int len) + { + xfs_trans_header_t *h; + char *cptr = *ptr; +- __uint32_t magic; ++ uint32_t magic; + char *magic_c = (char *)&magic; + + *ptr += len; + +- magic=*(__uint32_t*)cptr; /* XXX be32_to_cpu soon */ ++ magic = *(uint32_t *)cptr; /* XXX be32_to_cpu soon */ + + if (len >= 4) { + #if __BYTE_ORDER == __LITTLE_ENDIAN +@@ -201,7 +201,7 @@ xlog_print_trans_buffer(char **ptr, int len, int *i, int num_ops) + int num, skip; + int super_block = 0; + int bucket, col, buckets; +- __int64_t blkno; ++ int64_t blkno; + xfs_buf_log_format_t lbuf; + int size, blen, map_size, struct_size; + __be64 x, y; +diff --git a/mdrestore/xfs_mdrestore.c b/mdrestore/xfs_mdrestore.c +index 9d1b4e80..c49c13aa 100644 +--- a/mdrestore/xfs_mdrestore.c ++++ b/mdrestore/xfs_mdrestore.c +@@ -66,7 +66,7 @@ perform_restore( + int mb_count; + xfs_metablock_t tmb; + xfs_sb_t sb; +- __int64_t bytes_read; ++ int64_t bytes_read; + + /* + * read in first blocks (superblock 0), set "inprogress" flag for it, +diff --git a/mkfs/proto.c b/mkfs/proto.c +index 89cd2379..cf8cc391 100644 +--- a/mkfs/proto.c ++++ b/mkfs/proto.c +@@ -667,7 +667,7 @@ rtinit( + mp->m_sb.sb_rbmino = rbmip->i_ino; + rbmip->i_d.di_size = mp->m_sb.sb_rbmblocks * mp->m_sb.sb_blocksize; + rbmip->i_d.di_flags = XFS_DIFLAG_NEWRTBM; +- *(__uint64_t *)&VFS_I(rbmip)->i_atime = 0; ++ *(uint64_t *)&VFS_I(rbmip)->i_atime = 0; + libxfs_trans_log_inode(tp, rbmip, XFS_ILOG_CORE); + libxfs_log_sb(tp); + mp->m_rbmip = rbmip; +diff --git a/mkfs/xfs_mkfs.c b/mkfs/xfs_mkfs.c +index b5c3a57e..7bb6408f 100644 +--- a/mkfs/xfs_mkfs.c ++++ b/mkfs/xfs_mkfs.c +@@ -705,9 +705,9 @@ struct opt_params mopts = { + }, + }; + +-#define TERABYTES(count, blog) ((__uint64_t)(count) << (40 - (blog))) +-#define GIGABYTES(count, blog) ((__uint64_t)(count) << (30 - (blog))) +-#define MEGABYTES(count, blog) ((__uint64_t)(count) << (20 - (blog))) ++#define TERABYTES(count, blog) ((uint64_t)(count) << (40 - (blog))) ++#define GIGABYTES(count, blog) ((uint64_t)(count) << (30 - (blog))) ++#define MEGABYTES(count, blog) ((uint64_t)(count) << (20 - (blog))) + + /* + * Use this macro before we have superblock and mount structure +@@ -878,7 +878,7 @@ fixup_log_stripe_unit( + xfs_rfsblock_t *logblocks, + int blocklog) + { +- __uint64_t tmp_logblocks; ++ uint64_t tmp_logblocks; + + /* + * Make sure that the log size is a multiple of the stripe unit +@@ -910,7 +910,7 @@ fixup_internal_log_stripe( + xfs_mount_t *mp, + int lsflag, + xfs_fsblock_t logstart, +- __uint64_t agsize, ++ uint64_t agsize, + int sunit, + xfs_rfsblock_t *logblocks, + int blocklog, +@@ -934,7 +934,7 @@ fixup_internal_log_stripe( + } + + void +-validate_log_size(__uint64_t logblocks, int blocklog, int min_logblocks) ++validate_log_size(uint64_t logblocks, int blocklog, int min_logblocks) + { + if (logblocks < min_logblocks) { + fprintf(stderr, +@@ -959,7 +959,7 @@ validate_log_size(__uint64_t logblocks, int blocklog, int min_logblocks) + static int + calc_default_imaxpct( + int blocklog, +- __uint64_t dblocks) ++ uint64_t dblocks) + { + /* + * This returns the % of the disk space that is used for +@@ -981,9 +981,9 @@ calc_default_imaxpct( + static void + validate_ag_geometry( + int blocklog, +- __uint64_t dblocks, +- __uint64_t agsize, +- __uint64_t agcount) ++ uint64_t dblocks, ++ uint64_t agsize, ++ uint64_t agcount) + { + if (agsize < XFS_AG_MIN_BLOCKS(blocklog)) { + fprintf(stderr, +@@ -1059,7 +1059,7 @@ zero_old_xfs_structures( + { + void *buf; + xfs_sb_t sb; +- __uint32_t bsize; ++ uint32_t bsize; + int i; + xfs_off_t off; + +@@ -1112,8 +1112,8 @@ zero_old_xfs_structures( + i != sb.sb_blocklog) + goto done; + +- if (sb.sb_dblocks > ((__uint64_t)sb.sb_agcount * sb.sb_agblocks) || +- sb.sb_dblocks < ((__uint64_t)(sb.sb_agcount - 1) * ++ if (sb.sb_dblocks > ((uint64_t)sb.sb_agcount * sb.sb_agblocks) || ++ sb.sb_dblocks < ((uint64_t)(sb.sb_agcount - 1) * + sb.sb_agblocks + XFS_MIN_AG_BLOCKS)) + goto done; + +@@ -1133,7 +1133,7 @@ done: + } + + static void +-discard_blocks(dev_t dev, __uint64_t nsectors) ++discard_blocks(dev_t dev, uint64_t nsectors) + { + int fd; + +@@ -1395,11 +1395,11 @@ main( + int argc, + char **argv) + { +- __uint64_t agcount; ++ uint64_t agcount; + xfs_agf_t *agf; + xfs_agi_t *agi; + xfs_agnumber_t agno; +- __uint64_t agsize; ++ uint64_t agsize; + xfs_alloc_rec_t *arec; + struct xfs_btree_block *block; + int blflag; +@@ -1475,10 +1475,10 @@ main( + char *rtsize; + xfs_sb_t *sbp; + int sectorlog; +- __uint64_t sector_mask; ++ uint64_t sector_mask; + int slflag; + int ssflag; +- __uint64_t tmp_agsize; ++ uint64_t tmp_agsize; + uuid_t uuid; + int worst_freelist; + libxfs_init_t xi; +@@ -2167,7 +2167,7 @@ _("rmapbt not supported with realtime devices\n")); + + + if (dsize) { +- __uint64_t dbytes; ++ uint64_t dbytes; + + dbytes = getnum(dsize, &dopts, D_SIZE); + if (dbytes % XFS_MIN_BLOCKSIZE) { +@@ -2199,7 +2199,7 @@ _("rmapbt not supported with realtime devices\n")); + } + + if (logsize) { +- __uint64_t logbytes; ++ uint64_t logbytes; + + logbytes = getnum(logsize, &lopts, L_SIZE); + if (logbytes % XFS_MIN_BLOCKSIZE) { +@@ -2216,7 +2216,7 @@ _("rmapbt not supported with realtime devices\n")); + (long long)(logblocks << blocklog)); + } + if (rtsize) { +- __uint64_t rtbytes; ++ uint64_t rtbytes; + + rtbytes = getnum(rtsize, &ropts, R_SIZE); + if (rtbytes % XFS_MIN_BLOCKSIZE) { +@@ -2236,7 +2236,7 @@ _("rmapbt not supported with realtime devices\n")); + * If specified, check rt extent size against its constraints. + */ + if (rtextsize) { +- __uint64_t rtextbytes; ++ uint64_t rtextbytes; + + rtextbytes = getnum(rtextsize, &ropts, R_EXTSIZE); + if (rtextbytes % blocksize) { +@@ -2252,8 +2252,8 @@ _("rmapbt not supported with realtime devices\n")); + * and the underlying volume is striped, then set rtextblocks + * to the stripe width. + */ +- __uint64_t rswidth; +- __uint64_t rtextbytes; ++ uint64_t rswidth; ++ uint64_t rtextbytes; + + if (!norsflag && !xi.risfile && !(!rtsize && xi.disfile)) + rswidth = ft.rtswidth; +@@ -2335,10 +2335,10 @@ _("rmapbt not supported with realtime devices\n")); + * multiple of the sector size, or 1024, whichever is larger. + */ + +- sector_mask = (__uint64_t)-1 << (MAX(sectorlog, 10) - BBSHIFT); ++ sector_mask = (uint64_t)-1 << (MAX(sectorlog, 10) - BBSHIFT); + xi.dsize &= sector_mask; + xi.rtsize &= sector_mask; +- xi.logBBsize &= (__uint64_t)-1 << (MAX(lsectorlog, 10) - BBSHIFT); ++ xi.logBBsize &= (uint64_t)-1 << (MAX(lsectorlog, 10) - BBSHIFT); + + + /* don't do discards on print-only runs or on files */ +@@ -2696,9 +2696,9 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"), + mp = &mbuf; + sbp = &mp->m_sb; + memset(mp, 0, sizeof(xfs_mount_t)); +- sbp->sb_blocklog = (__uint8_t)blocklog; +- sbp->sb_sectlog = (__uint8_t)sectorlog; +- sbp->sb_agblklog = (__uint8_t)libxfs_log2_roundup((unsigned int)agsize); ++ sbp->sb_blocklog = (uint8_t)blocklog; ++ sbp->sb_sectlog = (uint8_t)sectorlog; ++ sbp->sb_agblklog = (uint8_t)libxfs_log2_roundup((unsigned int)agsize); + sbp->sb_agblocks = (xfs_agblock_t)agsize; + mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT; + mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT; +@@ -2805,14 +2805,14 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"), + sbp->sb_agcount = (xfs_agnumber_t)agcount; + sbp->sb_rbmblocks = nbmblocks; + sbp->sb_logblocks = (xfs_extlen_t)logblocks; +- sbp->sb_sectsize = (__uint16_t)sectorsize; +- sbp->sb_inodesize = (__uint16_t)isize; +- sbp->sb_inopblock = (__uint16_t)(blocksize / isize); +- sbp->sb_sectlog = (__uint8_t)sectorlog; +- sbp->sb_inodelog = (__uint8_t)inodelog; +- sbp->sb_inopblog = (__uint8_t)(blocklog - inodelog); ++ sbp->sb_sectsize = (uint16_t)sectorsize; ++ sbp->sb_inodesize = (uint16_t)isize; ++ sbp->sb_inopblock = (uint16_t)(blocksize / isize); ++ sbp->sb_sectlog = (uint8_t)sectorlog; ++ sbp->sb_inodelog = (uint8_t)inodelog; ++ sbp->sb_inopblog = (uint8_t)(blocklog - inodelog); + sbp->sb_rextslog = +- (__uint8_t)(rtextents ? ++ (uint8_t)(rtextents ? + libxfs_highbit32((unsigned int)rtextents) : 0); + sbp->sb_inprogress = 1; /* mkfs is in progress */ + sbp->sb_imax_pct = imaxpct; +@@ -2840,8 +2840,8 @@ _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"), + } else + sbp->sb_inoalignmt = 0; + if (lsectorsize != BBSIZE || sectorsize != BBSIZE) { +- sbp->sb_logsectlog = (__uint8_t)lsectorlog; +- sbp->sb_logsectsize = (__uint16_t)lsectorsize; ++ sbp->sb_logsectlog = (uint8_t)lsectorlog; ++ sbp->sb_logsectsize = (uint16_t)lsectorsize; + } else { + sbp->sb_logsectlog = 0; + sbp->sb_logsectsize = 0; +diff --git a/quota/edit.c b/quota/edit.c +index 36b327a5..8418e858 100644 +--- a/quota/edit.c ++++ b/quota/edit.c +@@ -115,16 +115,16 @@ warn_help(void) + + static void + set_limits( +- __uint32_t id, ++ uint32_t id, + uint type, + uint mask, + char *dev, +- __uint64_t *bsoft, +- __uint64_t *bhard, +- __uint64_t *isoft, +- __uint64_t *ihard, +- __uint64_t *rtbsoft, +- __uint64_t *rtbhard) ++ uint64_t *bsoft, ++ uint64_t *bhard, ++ uint64_t *isoft, ++ uint64_t *ihard, ++ uint64_t *rtbsoft, ++ uint64_t *rtbhard) + { + fs_disk_quota_t d; + +@@ -152,12 +152,12 @@ set_user_limits( + char *name, + uint type, + uint mask, +- __uint64_t *bsoft, +- __uint64_t *bhard, +- __uint64_t *isoft, +- __uint64_t *ihard, +- __uint64_t *rtbsoft, +- __uint64_t *rtbhard) ++ uint64_t *bsoft, ++ uint64_t *bhard, ++ uint64_t *isoft, ++ uint64_t *ihard, ++ uint64_t *rtbsoft, ++ uint64_t *rtbhard) + { + uid_t uid = uid_from_string(name); + +@@ -175,12 +175,12 @@ set_group_limits( + char *name, + uint type, + uint mask, +- __uint64_t *bsoft, +- __uint64_t *bhard, +- __uint64_t *isoft, +- __uint64_t *ihard, +- __uint64_t *rtbsoft, +- __uint64_t *rtbhard) ++ uint64_t *bsoft, ++ uint64_t *bhard, ++ uint64_t *isoft, ++ uint64_t *ihard, ++ uint64_t *rtbsoft, ++ uint64_t *rtbhard) + { + gid_t gid = gid_from_string(name); + +@@ -198,12 +198,12 @@ set_project_limits( + char *name, + uint type, + uint mask, +- __uint64_t *bsoft, +- __uint64_t *bhard, +- __uint64_t *isoft, +- __uint64_t *ihard, +- __uint64_t *rtbsoft, +- __uint64_t *rtbhard) ++ uint64_t *bsoft, ++ uint64_t *bhard, ++ uint64_t *isoft, ++ uint64_t *ihard, ++ uint64_t *rtbsoft, ++ uint64_t *rtbhard) + { + prid_t prid = prid_from_string(name); + +@@ -224,7 +224,7 @@ extractb( + int length, + uint blocksize, + uint sectorsize, +- __uint64_t *value) ++ uint64_t *value) + { + long long v; + char *s = string; +@@ -238,7 +238,7 @@ extractb( + progname, s); + return 0; + } +- *value = (__uint64_t)v >> 9; /* syscalls use basic blocks */ ++ *value = (uint64_t)v >> 9; /* syscalls use basic blocks */ + if (v > 0 && *value == 0) + fprintf(stderr, _("%s: Warning: `%s' in quota blocks is 0 (unlimited).\n"), progname, s); + return 1; +@@ -252,7 +252,7 @@ extracti( + char *string, + const char *prefix, + int length, +- __uint64_t *value) ++ uint64_t *value) + { + char *sp, *s = string; + +@@ -270,7 +270,7 @@ limit_f( + char **argv) + { + char *name; +- __uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard; ++ uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard; + int c, type = 0, mask = 0, flags = 0; + uint bsize, ssize, endoptions; + +@@ -384,8 +384,8 @@ restore_file( + char *dev = NULL; + uint mask; + int cnt; +- __uint32_t id; +- __uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard; ++ uint32_t id; ++ uint64_t bsoft, bhard, isoft, ihard, rtbsoft, rtbhard; + + while (fgets(buffer, sizeof(buffer), fp) != NULL) { + if (strncmp("fs = ", buffer, 5) == 0) { +@@ -546,7 +546,7 @@ timer_f( + + static void + set_warnings( +- __uint32_t id, ++ uint32_t id, + uint type, + uint mask, + char *dev, +diff --git a/quota/free.c b/quota/free.c +index cee15ee9..1f8378d2 100644 +--- a/quota/free.c ++++ b/quota/free.c +@@ -49,20 +49,20 @@ free_help(void) + static int + mount_free_space_data( + struct fs_path *mount, +- __uint64_t *bcount, +- __uint64_t *bused, +- __uint64_t *bfree, +- __uint64_t *icount, +- __uint64_t *iused, +- __uint64_t *ifree, +- __uint64_t *rcount, +- __uint64_t *rused, +- __uint64_t *rfree) ++ uint64_t *bcount, ++ uint64_t *bused, ++ uint64_t *bfree, ++ uint64_t *icount, ++ uint64_t *iused, ++ uint64_t *ifree, ++ uint64_t *rcount, ++ uint64_t *rused, ++ uint64_t *rfree) + { + struct xfs_fsop_counts fscounts; + struct xfs_fsop_geom fsgeo; + struct statfs st; +- __uint64_t logsize, count, free; ++ uint64_t logsize, count, free; + int fd; + + if ((fd = open(mount->fs_dir, O_RDONLY)) < 0) { +@@ -132,15 +132,15 @@ mount_free_space_data( + static int + projects_free_space_data( + struct fs_path *path, +- __uint64_t *bcount, +- __uint64_t *bused, +- __uint64_t *bfree, +- __uint64_t *icount, +- __uint64_t *iused, +- __uint64_t *ifree, +- __uint64_t *rcount, +- __uint64_t *rused, +- __uint64_t *rfree) ++ uint64_t *bcount, ++ uint64_t *bused, ++ uint64_t *bfree, ++ uint64_t *icount, ++ uint64_t *iused, ++ uint64_t *ifree, ++ uint64_t *rcount, ++ uint64_t *rused, ++ uint64_t *rfree) + { + fs_quota_stat_t qfs; + fs_disk_quota_t d; +@@ -226,9 +226,9 @@ free_space( + fs_path_t *path, + uint flags) + { +- __uint64_t bcount, bused, bfree; +- __uint64_t icount, iused, ifree; +- __uint64_t rcount, rused, rfree; ++ uint64_t bcount, bused, bfree; ++ uint64_t icount, iused, ifree; ++ uint64_t rcount, rused, rfree; + char a[8], s[8], u[8], p[8]; + int count; + +diff --git a/quota/quot.c b/quota/quot.c +index ccc154f5..6378fbb7 100644 +--- a/quota/quot.c ++++ b/quota/quot.c +@@ -26,17 +26,17 @@ + + typedef struct du { + struct du *next; +- __uint64_t blocks; +- __uint64_t blocks30; +- __uint64_t blocks60; +- __uint64_t blocks90; +- __uint64_t nfiles; +- __uint32_t id; ++ uint64_t blocks; ++ uint64_t blocks30; ++ uint64_t blocks60; ++ uint64_t blocks90; ++ uint64_t nfiles; ++ uint32_t id; + } du_t; + + #define TSIZE 500 +-static __uint64_t sizes[TSIZE]; +-static __uint64_t overflow; ++static uint64_t sizes[TSIZE]; ++static uint64_t overflow; + + #define NDU 60000 + #define DUHASH 8209 +@@ -84,8 +84,8 @@ quot_bulkstat_add( + { + du_t *dp; + du_t **hp; +- __uint64_t size; +- __uint32_t i, id; ++ uint64_t size; ++ uint32_t i, id; + + if ((p->bs_mode & S_IFMT) == 0) + return; +@@ -203,7 +203,7 @@ qcompare( + return 0; + } + +-typedef char *(*idtoname_t)(__uint32_t); ++typedef char *(*idtoname_t)(uint32_t); + + static void + quot_report_mount_any_type( +@@ -291,7 +291,7 @@ quot_histogram_mount( + fs_path_t *mount, + uint flags) + { +- __uint64_t t = 0; ++ uint64_t t = 0; + int i; + + fprintf(fp, _("%s (%s):\n"), mount->fs_name, mount->fs_dir); +diff --git a/quota/quota.c b/quota/quota.c +index d09e239b..479b970e 100644 +--- a/quota/quota.c ++++ b/quota/quota.c +@@ -52,7 +52,7 @@ quota_help(void) + static int + quota_mount( + FILE *fp, +- __uint32_t id, ++ uint32_t id, + char *name, + uint form, + uint type, +@@ -181,7 +181,7 @@ quota_mount( + static void + quota( + FILE *fp, +- __uint32_t id, ++ uint32_t id, + char *name, + uint form, + uint type, +diff --git a/quota/quota.h b/quota/quota.h +index 4bde3513..9ed28bee 100644 +--- a/quota/quota.h ++++ b/quota/quota.h +@@ -53,9 +53,9 @@ enum { + extern char *type_to_string(uint __type); + extern char *form_to_string(uint __form); + extern char *time_to_string(time_t __time, uint __flags); +-extern char *bbs_to_string(__uint64_t __v, char *__c, uint __size); +-extern char *num_to_string(__uint64_t __v, char *__c, uint __size); +-extern char *pct_to_string(__uint64_t __v, __uint64_t __t, char *__c, uint __s); ++extern char *bbs_to_string(uint64_t __v, char *__c, uint __size); ++extern char *num_to_string(uint64_t __v, char *__c, uint __size); ++extern char *pct_to_string(uint64_t __v, uint64_t __t, char *__c, uint __s); + + extern FILE *fopen_write_secure(char *__filename); + +@@ -81,7 +81,7 @@ enum { + * Identifier (uid/gid/prid) cache routines + */ + #define NMAX 32 +-extern char *uid_to_name(__uint32_t __uid); +-extern char *gid_to_name(__uint32_t __gid); +-extern char *prid_to_name(__uint32_t __prid); ++extern char *uid_to_name(uint32_t __uid); ++extern char *gid_to_name(uint32_t __gid); ++extern char *prid_to_name(uint32_t __prid); + extern bool isdigits_only(const char *); +diff --git a/quota/report.c b/quota/report.c +index d0509c25..b2ea3bbe 100644 +--- a/quota/report.c ++++ b/quota/report.c +@@ -333,9 +333,9 @@ report_header( + static int + report_mount( + FILE *fp, +- __uint32_t id, ++ uint32_t id, + char *name, +- __uint32_t *oid, ++ uint32_t *oid, + uint form, + uint type, + fs_path_t *mount, +diff --git a/quota/state.c b/quota/state.c +index 09dfa705..b08bf50b 100644 +--- a/quota/state.c ++++ b/quota/state.c +@@ -135,7 +135,7 @@ static void + state_timelimit( + FILE *fp, + uint form, +- __uint32_t timelimit) ++ uint32_t timelimit) + { + fprintf(fp, _("%s grace time: %s\n"), + form_to_string(form), +diff --git a/quota/util.c b/quota/util.c +index cafd45f5..37840a86 100644 +--- a/quota/util.c ++++ b/quota/util.c +@@ -94,8 +94,8 @@ round_snprintf( + size_t size, + const char *fmt_round, + const char *fmt_not_round, +- __uint64_t value, +- __uint64_t divisor) ++ uint64_t value, ++ uint64_t divisor) + { + double v = (double)value / divisor; + +@@ -107,23 +107,23 @@ round_snprintf( + } + + /* Basic blocks (512) bytes are returned from quotactl */ +-#define BBS_TO_EXABYTES(bbs) ((__uint64_t)(bbs)>>51) +-#define BBS_TO_PETABYTES(bbs) ((__uint64_t)(bbs)>>41) +-#define BBS_TO_TERABYTES(bbs) ((__uint64_t)(bbs)>>31) +-#define BBS_TO_GIGABYTES(bbs) ((__uint64_t)(bbs)>>21) +-#define BBS_TO_MEGABYTES(bbs) ((__uint64_t)(bbs)>>11) +-#define BBS_TO_KILOBYTES(bbs) ((__uint64_t)(bbs)>>1) +- +-#define BBEXABYTE ((__uint64_t)1<<51) +-#define BBPETABYTE ((__uint64_t)1<<41) +-#define BBTERABYTE ((__uint64_t)1<<31) +-#define BBGIGABYTE ((__uint64_t)1<<21) +-#define BBMEGABYTE ((__uint64_t)1<<11) +-#define BBKILOBYTE ((__uint64_t)1<< 1) ++#define BBS_TO_EXABYTES(bbs) ((uint64_t)(bbs)>>51) ++#define BBS_TO_PETABYTES(bbs) ((uint64_t)(bbs)>>41) ++#define BBS_TO_TERABYTES(bbs) ((uint64_t)(bbs)>>31) ++#define BBS_TO_GIGABYTES(bbs) ((uint64_t)(bbs)>>21) ++#define BBS_TO_MEGABYTES(bbs) ((uint64_t)(bbs)>>11) ++#define BBS_TO_KILOBYTES(bbs) ((uint64_t)(bbs)>>1) ++ ++#define BBEXABYTE ((uint64_t)1<<51) ++#define BBPETABYTE ((uint64_t)1<<41) ++#define BBTERABYTE ((uint64_t)1<<31) ++#define BBGIGABYTE ((uint64_t)1<<21) ++#define BBMEGABYTE ((uint64_t)1<<11) ++#define BBKILOBYTE ((uint64_t)1<< 1) + + char * + bbs_to_string( +- __uint64_t v, ++ uint64_t v, + char *sp, + uint size) + { +@@ -146,17 +146,17 @@ bbs_to_string( + return sp; + } + +-#define THOUSAND ((__uint64_t)1000) +-#define MILLION ((__uint64_t)1000*1000) +-#define BILLION ((__uint64_t)1000*1000*1000) +-#define TRILLION ((__uint64_t)1000*1000*1000*1000) +-#define GAZILLION ((__uint64_t)1000*1000*1000*1000*1000) +-#define RIDICULOUS ((__uint64_t)1000*1000*1000*1000*1000*1000) +-#define STOPALREADY ((__uint64_t)1000*1000*1000*1000*1000*1000*1000) ++#define THOUSAND ((uint64_t)1000) ++#define MILLION ((uint64_t)1000*1000) ++#define BILLION ((uint64_t)1000*1000*1000) ++#define TRILLION ((uint64_t)1000*1000*1000*1000) ++#define GAZILLION ((uint64_t)1000*1000*1000*1000*1000) ++#define RIDICULOUS ((uint64_t)1000*1000*1000*1000*1000*1000) ++#define STOPALREADY ((uint64_t)1000*1000*1000*1000*1000*1000*1000) + + char * + num_to_string( +- __uint64_t v, ++ uint64_t v, + char *sp, + uint size) + { +@@ -183,8 +183,8 @@ num_to_string( + + char * + pct_to_string( +- __uint64_t portion, +- __uint64_t whole, ++ uint64_t portion, ++ uint64_t whole, + char *buf, + uint size) + { +@@ -237,7 +237,7 @@ type_to_string( + #define IDMASK (NID-1) + + typedef struct { +- __uint32_t id; ++ uint32_t id; + char name[NMAX+1]; + } idcache_t; + +@@ -250,7 +250,7 @@ static int pentriesleft = NID; + + static idcache_t * + getnextpwent( +- __uint32_t id, ++ uint32_t id, + int byid) + { + struct passwd *pw; +@@ -266,7 +266,7 @@ getnextpwent( + + static idcache_t * + getnextgrent( +- __uint32_t id, ++ uint32_t id, + int byid) + { + struct group *gr; +@@ -281,7 +281,7 @@ getnextgrent( + + static idcache_t * + getnextprent( +- __uint32_t id, ++ uint32_t id, + int byid) + { + fs_project_t *pr; +@@ -296,7 +296,7 @@ getnextprent( + + char * + uid_to_name( +- __uint32_t id) ++ uint32_t id) + { + idcache_t *ncp, *idp; + +@@ -333,7 +333,7 @@ uid_to_name( + + char * + gid_to_name( +- __uint32_t id) ++ uint32_t id) + { + idcache_t *ncp, *idp; + +@@ -370,7 +370,7 @@ gid_to_name( + + char * + prid_to_name( +- __uint32_t id) ++ uint32_t id) + { + idcache_t *ncp, *idp; + +diff --git a/repair/README b/repair/README +index 7f168e69..4692463d 100644 +--- a/repair/README ++++ b/repair/README +@@ -189,7 +189,7 @@ D - 0) look at usage of XFS_MAKE_IPTR(). It does the right + + + D - 0) look at references to XFS_INODES_PER_CHUNK. change the +- ones that really mean sizeof(__uint64_t)*NBBY to ++ ones that really mean sizeof(uint64_t)*NBBY to + something else (like that only defined as a constant + INOS_PER_IREC. this isn't as important since + XFS_INODES_PER_CHUNK will never chang +diff --git a/repair/agheader.h b/repair/agheader.h +index 6b2974ca..2f7246d2 100644 +--- a/repair/agheader.h ++++ b/repair/agheader.h +@@ -20,7 +20,7 @@ typedef struct fs_geometry { + /* + * these types should match the superblock types + */ +- __uint32_t sb_blocksize; /* blocksize (bytes) */ ++ uint32_t sb_blocksize; /* blocksize (bytes) */ + xfs_rfsblock_t sb_dblocks; /* # data blocks */ + xfs_rfsblock_t sb_rblocks; /* # realtime blocks */ + xfs_rtblock_t sb_rextents; /* # realtime extents */ +@@ -30,9 +30,9 @@ typedef struct fs_geometry { + xfs_agnumber_t sb_agcount; /* # of ags */ + xfs_extlen_t sb_rbmblocks; /* # of rt bitmap blocks */ + xfs_extlen_t sb_logblocks; /* # of log blocks */ +- __uint16_t sb_sectsize; /* volume sector size (bytes) */ +- __uint16_t sb_inodesize; /* inode size (bytes) */ +- __uint8_t sb_imax_pct; /* max % of fs for inode space */ ++ uint16_t sb_sectsize; /* volume sector size (bytes) */ ++ uint16_t sb_inodesize; /* inode size (bytes) */ ++ uint8_t sb_imax_pct; /* max % of fs for inode space */ + + /* + * these don't have to match the superblock types but are placed +@@ -49,10 +49,10 @@ typedef struct fs_geometry { + /* + * fields after this point have to be checked manually in compare_sb() + */ +- __uint8_t sb_shared_vn; /* shared version number */ ++ uint8_t sb_shared_vn; /* shared version number */ + xfs_extlen_t sb_inoalignmt; /* inode chunk alignment, fsblocks */ +- __uint32_t sb_unit; /* stripe or raid unit */ +- __uint32_t sb_width; /* stripe or width unit */ ++ uint32_t sb_unit; /* stripe or raid unit */ ++ uint32_t sb_width; /* stripe or width unit */ + + /* + * these don't have to match, they track superblock properties +diff --git a/repair/attr_repair.h b/repair/attr_repair.h +index 7010e4ff..294fad44 100644 +--- a/repair/attr_repair.h ++++ b/repair/attr_repair.h +@@ -32,10 +32,10 @@ + #define ACL_WRITE 02 + #define ACL_EXECUTE 01 + +-typedef __uint16_t xfs_acl_perm_t; +-typedef __int32_t xfs_acl_type_t; +-typedef __int32_t xfs_acl_tag_t; +-typedef __int32_t xfs_acl_id_t; ++typedef uint16_t xfs_acl_perm_t; ++typedef int32_t xfs_acl_type_t; ++typedef int32_t xfs_acl_tag_t; ++typedef int32_t xfs_acl_id_t; + + /* + * "icacl" = in-core ACL. There is no equivalent in the XFS kernel code, +@@ -50,7 +50,7 @@ struct xfs_icacl_entry { + }; + + struct xfs_icacl { +- __int32_t acl_cnt; ++ int32_t acl_cnt; + struct xfs_icacl_entry acl_entry[0]; + }; + +@@ -59,14 +59,14 @@ struct xfs_icacl { + */ + #define XFS_MAC_MAX_SETS 250 + typedef struct xfs_mac_label { +- __uint8_t ml_msen_type; /* MSEN label type */ +- __uint8_t ml_mint_type; /* MINT label type */ +- __uint8_t ml_level; /* Hierarchical level */ +- __uint8_t ml_grade; /* Hierarchical grade */ +- __uint16_t ml_catcount; /* Category count */ +- __uint16_t ml_divcount; /* Division count */ ++ uint8_t ml_msen_type; /* MSEN label type */ ++ uint8_t ml_mint_type; /* MINT label type */ ++ uint8_t ml_level; /* Hierarchical level */ ++ uint8_t ml_grade; /* Hierarchical grade */ ++ uint16_t ml_catcount; /* Category count */ ++ uint16_t ml_divcount; /* Division count */ + /* Category set, then Division set */ +- __uint16_t ml_list[XFS_MAC_MAX_SETS]; ++ uint16_t ml_list[XFS_MAC_MAX_SETS]; + } xfs_mac_label_t; + + /* MSEN label type names. Choose an upper case ASCII character. */ +@@ -93,7 +93,7 @@ typedef struct xfs_mac_label { + /* + * Capabilities (IRIX) + */ +-typedef __uint64_t xfs_cap_value_t; ++typedef uint64_t xfs_cap_value_t; + + typedef struct xfs_cap_set { + xfs_cap_value_t cap_effective; /* use in capability checks */ +diff --git a/repair/avl64.c b/repair/avl64.c +index 51cd624c..8f4a1211 100644 +--- a/repair/avl64.c ++++ b/repair/avl64.c +@@ -70,8 +70,8 @@ avl64_checktree( + avl64node_t *root) + { + avl64node_t *nlast, *nnext, *np; +- __uint64_t offset = 0; +- __uint64_t end; ++ uint64_t offset = 0; ++ uint64_t end; + + nlast = nnext = root; + +@@ -583,8 +583,8 @@ attach: + avl64node_t * + avl64_findanyrange( + avl64tree_desc_t *tree, +- __uint64_t start, +- __uint64_t end, ++ uint64_t start, ++ uint64_t end, + int checklen) + { + avl64node_t *np = tree->avl_root; +@@ -655,7 +655,7 @@ avl64_findanyrange( + avl64node_t * + avl64_findrange( + avl64tree_desc_t *tree, +- __uint64_t value) ++ uint64_t value) + { + avl64node_t *np = tree->avl_root; + +@@ -682,10 +682,10 @@ avl64_findrange( + avl64node_t * + avl64_find( + avl64tree_desc_t *tree, +- __uint64_t value) ++ uint64_t value) + { + avl64node_t *np = tree->avl_root; +- __uint64_t nvalue; ++ uint64_t nvalue; + + while (np) { + nvalue = AVL_START(tree, np); +@@ -909,8 +909,8 @@ static + avl64node_t * + avl64_insert_find_growth( + avl64tree_desc_t *tree, +- __uint64_t start, /* range start at start, */ +- __uint64_t end, /* exclusive */ ++ uint64_t start, /* range start at start, */ ++ uint64_t end, /* exclusive */ + int *growthp) /* OUT */ + { + avl64node_t *root = tree->avl_root; +@@ -963,7 +963,7 @@ avl64_insert_grow( + int growth) + { + avl64node_t *nnext; +- __uint64_t start = AVL_START(tree, newnode); ++ uint64_t start = AVL_START(tree, newnode); + + if (growth == AVL_BACK) { + +@@ -1005,8 +1005,8 @@ avl64_insert( + avl64node_t *newnode) + { + avl64node_t *np; +- __uint64_t start = AVL_START(tree, newnode); +- __uint64_t end = AVL_END(tree, newnode); ++ uint64_t start = AVL_START(tree, newnode); ++ uint64_t end = AVL_END(tree, newnode); + int growth; + + ASSERT(newnode); +@@ -1159,16 +1159,16 @@ avl64ops_t avl_debug_ops = { + avl_debug_end, + } + +-static __uint64_t ++static uint64_t + avl64_debug_start(avl64node_t *node) + { +- return (__uint64_t)(struct avl_debug_node *)node->avl_start; ++ return (uint64_t)(struct avl_debug_node *)node->avl_start; + } + +-static __uint64_t ++static uint64_t + avl64_debug_end(avl64node_t *node) + { +- return (__uint64_t) ++ return (uint64_t) + ((struct avl_debug_node *)node->avl_start + + (struct avl_debug_node *)node->avl_size); + } +@@ -1304,7 +1304,7 @@ main() + avl64node_t * + avl64_findadjacent( + avl64tree_desc_t *tree, +- __uint64_t value, ++ uint64_t value, + int dir) + { + avl64node_t *np = tree->avl_root; +@@ -1378,8 +1378,8 @@ avl64_findadjacent( + void + avl64_findranges( + avl64tree_desc_t *tree, +- __uint64_t start, +- __uint64_t end, ++ uint64_t start, ++ uint64_t end, + avl64node_t **startp, + avl64node_t **endp) + { +diff --git a/repair/avl64.h b/repair/avl64.h +index fd193218..cd079a00 100644 +--- a/repair/avl64.h ++++ b/repair/avl64.h +@@ -32,8 +32,8 @@ typedef struct avl64node { + * avl-tree operations + */ + typedef struct avl64ops { +- __uint64_t (*avl_start)(avl64node_t *); +- __uint64_t (*avl_end)(avl64node_t *); ++ uint64_t (*avl_start)(avl64node_t *); ++ uint64_t (*avl_end)(avl64node_t *); + } avl64ops_t; + + /* +@@ -89,32 +89,32 @@ avl64_init_tree( + avl64node_t * + avl64_findrange( + avl64tree_desc_t *tree, +- __uint64_t value); ++ uint64_t value); + + avl64node_t * + avl64_find( + avl64tree_desc_t *tree, +- __uint64_t value); ++ uint64_t value); + + avl64node_t * + avl64_findanyrange( + avl64tree_desc_t *tree, +- __uint64_t start, +- __uint64_t end, ++ uint64_t start, ++ uint64_t end, + int checklen); + + + avl64node_t * + avl64_findadjacent( + avl64tree_desc_t *tree, +- __uint64_t value, ++ uint64_t value, + int dir); + + void + avl64_findranges( + avl64tree_desc_t *tree, +- __uint64_t start, +- __uint64_t end, ++ uint64_t start, ++ uint64_t end, + avl64node_t **startp, + avl64node_t **endp); + +diff --git a/repair/dinode.c b/repair/dinode.c +index d664f87a..da872178 100644 +--- a/repair/dinode.c ++++ b/repair/dinode.c +@@ -746,7 +746,7 @@ _("%s fork in ino %" PRIu64 " claims dup extent, " + case XR_E_FREE1: + do_warn( + _("%s fork in ino %" PRIu64 " claims free block %" PRIu64 "\n"), +- forkname, ino, (__uint64_t) b); ++ forkname, ino, (uint64_t) b); + /* fall through ... */ + case XR_E_INUSE1: /* seen by rmap */ + case XR_E_UNKNOWN: +@@ -923,7 +923,7 @@ process_btinode( + int type, + int *dirty, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + blkmap_t **blkmapp, + int whichfork, + int check_dups) +@@ -939,7 +939,7 @@ process_btinode( + int level; + int numrecs; + bmap_cursor_t cursor; +- __uint64_t magic; ++ uint64_t magic; + + dib = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork); + lino = XFS_AGINO_TO_INO(mp, agno, ino); +@@ -1098,7 +1098,7 @@ process_exinode( + int type, + int *dirty, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + blkmap_t **blkmapp, + int whichfork, + int check_dups) +@@ -1200,14 +1200,14 @@ process_symlink_extlist(xfs_mount_t *mp, xfs_ino_t lino, xfs_dinode_t *dino) + do_warn( + _("mismatch between format (%d) and size (%" PRId64 ") in symlink ino %" PRIu64 "\n"), + dino->di_format, +- (__int64_t)be64_to_cpu(dino->di_size), lino); ++ (int64_t)be64_to_cpu(dino->di_size), lino); + return 1; + } + if (dino->di_format == XFS_DINODE_FMT_LOCAL) { + do_warn( + _("mismatch between format (%d) and size (%" PRId64 ") in symlink inode %" PRIu64 "\n"), + dino->di_format, +- (__int64_t)be64_to_cpu(dino->di_size), lino); ++ (int64_t)be64_to_cpu(dino->di_size), lino); + return 1; + } + +@@ -1454,22 +1454,22 @@ _("inode %" PRIu64 " has bad inode type (IFMNT)\n"), lino); + case XR_INO_CHRDEV: + do_warn( + _("size of character device inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino, +- (__int64_t)be64_to_cpu(dino->di_size)); ++ (int64_t)be64_to_cpu(dino->di_size)); + break; + case XR_INO_BLKDEV: + do_warn( + _("size of block device inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino, +- (__int64_t)be64_to_cpu(dino->di_size)); ++ (int64_t)be64_to_cpu(dino->di_size)); + break; + case XR_INO_SOCK: + do_warn( + _("size of socket inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino, +- (__int64_t)be64_to_cpu(dino->di_size)); ++ (int64_t)be64_to_cpu(dino->di_size)); + break; + case XR_INO_FIFO: + do_warn( + _("size of fifo inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino, +- (__int64_t)be64_to_cpu(dino->di_size)); ++ (int64_t)be64_to_cpu(dino->di_size)); + break; + default: + do_warn(_("Internal error - process_misc_ino_types, " +@@ -1743,12 +1743,12 @@ _("found inode %" PRIu64 " claiming to be a real-time file\n"), lino); + break; + + case XR_INO_RTBITMAP: +- if (size != (__int64_t)mp->m_sb.sb_rbmblocks * ++ if (size != (int64_t)mp->m_sb.sb_rbmblocks * + mp->m_sb.sb_blocksize) { + do_warn( + _("realtime bitmap inode %" PRIu64 " has bad size %" PRId64 " (should be %" PRIu64 ")\n"), + lino, size, +- (__int64_t) mp->m_sb.sb_rbmblocks * ++ (int64_t) mp->m_sb.sb_rbmblocks * + mp->m_sb.sb_blocksize); + return 1; + } +@@ -1817,8 +1817,8 @@ static int + process_inode_blocks_and_extents( + xfs_dinode_t *dino, + xfs_rfsblock_t nblocks, +- __uint64_t nextents, +- __uint64_t anextents, ++ uint64_t nextents, ++ uint64_t anextents, + xfs_ino_t lino, + int *dirty) + { +@@ -1908,7 +1908,7 @@ process_inode_data_fork( + int type, + int *dirty, + xfs_rfsblock_t *totblocks, +- __uint64_t *nextents, ++ uint64_t *nextents, + blkmap_t **dblkmap, + int check_dups) + { +@@ -2017,7 +2017,7 @@ process_inode_attr_fork( + int type, + int *dirty, + xfs_rfsblock_t *atotblocks, +- __uint64_t *anextents, ++ uint64_t *anextents, + int check_dups, + int extra_attr_check, + int *retval) +@@ -2228,8 +2228,8 @@ process_dinode_int(xfs_mount_t *mp, + int di_mode; + int type; + int retval = 0; +- __uint64_t nextents; +- __uint64_t anextents; ++ uint64_t nextents; ++ uint64_t anextents; + xfs_ino_t lino; + const int is_free = 0; + const int is_used = 1; +@@ -2346,7 +2346,7 @@ _("inode identifier %llu mismatch on inode %" PRIu64 "\n"), + if (!uncertain) + do_warn( + _("bad (negative) size %" PRId64 " on inode %" PRIu64 "\n"), +- (__int64_t)be64_to_cpu(dino->di_size), ++ (int64_t)be64_to_cpu(dino->di_size), + lino); + if (verify_mode) + return 1; +diff --git a/repair/dinode.h b/repair/dinode.h +index 61d07363..39d6a72f 100644 +--- a/repair/dinode.h ++++ b/repair/dinode.h +@@ -46,8 +46,8 @@ process_bmbt_reclist(xfs_mount_t *mp, + xfs_ino_t ino, + xfs_rfsblock_t *tot, + struct blkmap **blkmapp, +- __uint64_t *first_key, +- __uint64_t *last_key, ++ uint64_t *first_key, ++ uint64_t *last_key, + int whichfork); + + int +diff --git a/repair/dir2.c b/repair/dir2.c +index e6415e49..73dff902 100644 +--- a/repair/dir2.c ++++ b/repair/dir2.c +@@ -160,7 +160,7 @@ process_sf_dir2( + int bad_sfnamelen; + int i; + int i8; +- __int64_t ino_dir_size; ++ int64_t ino_dir_size; + int ino_off; + ino_tree_node_t *irec_p; + int junkit; +diff --git a/repair/globals.h b/repair/globals.h +index 4085ccc4..c7bbe6f1 100644 +--- a/repair/globals.h ++++ b/repair/globals.h +@@ -141,7 +141,7 @@ EXTERN int inodes_per_cluster; + EXTERN unsigned int glob_agcount; + EXTERN int chunks_pblock; /* # of 64-ino chunks per allocation */ + EXTERN int max_symlink_blocks; +-EXTERN __int64_t fs_max_file_offset; ++EXTERN int64_t fs_max_file_offset; + + /* realtime info */ + +@@ -161,24 +161,24 @@ EXTERN int full_ino_ex_data;/* + + /* superblock counters */ + +-EXTERN __uint64_t sb_icount; /* allocated (made) inodes */ +-EXTERN __uint64_t sb_ifree; /* free inodes */ +-EXTERN __uint64_t sb_fdblocks; /* free data blocks */ +-EXTERN __uint64_t sb_frextents; /* free realtime extents */ ++EXTERN uint64_t sb_icount; /* allocated (made) inodes */ ++EXTERN uint64_t sb_ifree; /* free inodes */ ++EXTERN uint64_t sb_fdblocks; /* free data blocks */ ++EXTERN uint64_t sb_frextents; /* free realtime extents */ + + /* superblock geometry info */ + + EXTERN xfs_extlen_t sb_inoalignmt; +-EXTERN __uint32_t sb_unit; +-EXTERN __uint32_t sb_width; ++EXTERN uint32_t sb_unit; ++EXTERN uint32_t sb_width; + + struct aglock { + pthread_mutex_t lock __attribute__((__aligned__(64))); + }; + EXTERN struct aglock *ag_locks; + +-EXTERN int report_interval; +-EXTERN __uint64_t *prog_rpt_done; ++EXTERN int report_interval; ++EXTERN uint64_t *prog_rpt_done; + + EXTERN int ag_stride; + EXTERN int thread_count; +diff --git a/repair/incore.c b/repair/incore.c +index cb573165..a9191ae2 100644 +--- a/repair/incore.c ++++ b/repair/incore.c +@@ -179,7 +179,7 @@ get_bmap_ext( + static uint64_t *rt_bmap; + static size_t rt_bmap_size; + +-/* block records fit into __uint64_t's units */ ++/* block records fit into uint64_t's units */ + #define XR_BB_UNIT 64 /* number of bits/unit */ + #define XR_BB 4 /* bits per block record */ + #define XR_BB_NUM (XR_BB_UNIT/XR_BB) /* number of records per unit */ +@@ -203,8 +203,8 @@ set_rtbmap( + { + *(rt_bmap + bno / XR_BB_NUM) = + ((*(rt_bmap + bno / XR_BB_NUM) & +- (~((__uint64_t) XR_BB_MASK << ((bno % XR_BB_NUM) * XR_BB)))) | +- (((__uint64_t) state) << ((bno % XR_BB_NUM) * XR_BB))); ++ (~((uint64_t) XR_BB_MASK << ((bno % XR_BB_NUM) * XR_BB)))) | ++ (((uint64_t) state) << ((bno % XR_BB_NUM) * XR_BB))); + } + + static void +@@ -222,9 +222,9 @@ init_rt_bmap( + return; + + rt_bmap_size = roundup(mp->m_sb.sb_rextents / (NBBY / XR_BB), +- sizeof(__uint64_t)); ++ sizeof(uint64_t)); + +- rt_bmap = memalign(sizeof(__uint64_t), rt_bmap_size); ++ rt_bmap = memalign(sizeof(uint64_t), rt_bmap_size); + if (!rt_bmap) { + do_error( + _("couldn't allocate realtime block map, size = %" PRIu64 "\n"), +diff --git a/repair/incore.h b/repair/incore.h +index c23a3a3c..fd66084f 100644 +--- a/repair/incore.h ++++ b/repair/incore.h +@@ -257,7 +257,7 @@ typedef xfs_ino_t parent_entry_t; + struct nlink_ops; + + typedef struct parent_list { +- __uint64_t pmask; ++ uint64_t pmask; + parent_entry_t *pentries; + #ifdef DEBUG + short cnt; +@@ -265,14 +265,14 @@ typedef struct parent_list { + } parent_list_t; + + union ino_nlink { +- __uint8_t *un8; +- __uint16_t *un16; +- __uint32_t *un32; ++ uint8_t *un8; ++ uint16_t *un16; ++ uint32_t *un32; + }; + + typedef struct ino_ex_data { +- __uint64_t ino_reached; /* bit == 1 if reached */ +- __uint64_t ino_processed; /* reference checked bit mask */ ++ uint64_t ino_reached; /* bit == 1 if reached */ ++ uint64_t ino_processed; /* reference checked bit mask */ + parent_list_t *parents; + union ino_nlink counted_nlinks;/* counted nlinks in P6 */ + } ino_ex_data_t; +@@ -281,22 +281,22 @@ typedef struct ino_tree_node { + avlnode_t avl_node; + xfs_agino_t ino_startnum; /* starting inode # */ + xfs_inofree_t ir_free; /* inode free bit mask */ +- __uint64_t ir_sparse; /* sparse inode bitmask */ +- __uint64_t ino_confirmed; /* confirmed bitmask */ +- __uint64_t ino_isa_dir; /* bit == 1 if a directory */ +- __uint64_t ino_was_rl; /* bit == 1 if reflink flag set */ +- __uint64_t ino_is_rl; /* bit == 1 if reflink flag should be set */ +- __uint8_t nlink_size; ++ uint64_t ir_sparse; /* sparse inode bitmask */ ++ uint64_t ino_confirmed; /* confirmed bitmask */ ++ uint64_t ino_isa_dir; /* bit == 1 if a directory */ ++ uint64_t ino_was_rl; /* bit == 1 if reflink flag set */ ++ uint64_t ino_is_rl; /* bit == 1 if reflink flag should be set */ ++ uint8_t nlink_size; + union ino_nlink disk_nlinks; /* on-disk nlinks, set in P3 */ + union { + ino_ex_data_t *ex_data; /* phases 6,7 */ + parent_list_t *plist; /* phases 2-5 */ + } ino_un; +- __uint8_t *ftypes; /* phases 3,6 */ ++ uint8_t *ftypes; /* phases 3,6 */ + } ino_tree_node_t; + +-#define INOS_PER_IREC (sizeof(__uint64_t) * NBBY) +-#define IREC_MASK(i) ((__uint64_t)1 << (i)) ++#define INOS_PER_IREC (sizeof(uint64_t) * NBBY) ++#define IREC_MASK(i) ((uint64_t)1 << (i)) + + void add_ino_ex_data(xfs_mount_t *mp); + +@@ -543,10 +543,10 @@ static inline int inode_is_rl(struct ino_tree_node *irec, int offset) + */ + void add_inode_ref(struct ino_tree_node *irec, int offset); + void drop_inode_ref(struct ino_tree_node *irec, int offset); +-__uint32_t num_inode_references(struct ino_tree_node *irec, int offset); ++uint32_t num_inode_references(struct ino_tree_node *irec, int offset); + +-void set_inode_disk_nlinks(struct ino_tree_node *irec, int offset, __uint32_t nlinks); +-__uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int offset); ++void set_inode_disk_nlinks(struct ino_tree_node *irec, int offset, uint32_t nlinks); ++uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int offset); + + static inline int is_inode_reached(struct ino_tree_node *irec, int offset) + { +@@ -567,13 +567,13 @@ static inline void add_inode_reached(struct ino_tree_node *irec, int offset) + static inline void + set_inode_ftype(struct ino_tree_node *irec, + int ino_offset, +- __uint8_t ftype) ++ uint8_t ftype) + { + if (irec->ftypes) + irec->ftypes[ino_offset] = ftype; + } + +-static inline __uint8_t ++static inline uint8_t + get_inode_ftype( + struct ino_tree_node *irec, + int ino_offset) +@@ -606,11 +606,11 @@ typedef struct bm_level_state { + xfs_fsblock_t fsbno; + xfs_fsblock_t left_fsbno; + xfs_fsblock_t right_fsbno; +- __uint64_t first_key; +- __uint64_t last_key; ++ uint64_t first_key; ++ uint64_t last_key; + /* + int level; +- __uint64_t prev_last_key; ++ uint64_t prev_last_key; + xfs_buf_t *bp; + xfs_bmbt_block_t *block; + */ +diff --git a/repair/incore_ext.c b/repair/incore_ext.c +index 7e6786c5..0a8138a9 100644 +--- a/repair/incore_ext.c ++++ b/repair/incore_ext.c +@@ -721,13 +721,13 @@ search_rt_dup_extent(xfs_mount_t *mp, xfs_rtblock_t bno) + return(ret); + } + +-static __uint64_t ++static uint64_t + avl64_rt_ext_start(avl64node_t *node) + { + return(((rt_extent_tree_node_t *) node)->rt_startblock); + } + +-static __uint64_t ++static uint64_t + avl64_ext_end(avl64node_t *node) + { + return(((rt_extent_tree_node_t *) node)->rt_startblock + +@@ -834,7 +834,7 @@ count_extents(xfs_agnumber_t agno, avltree_desc_t *tree, int whichtree) + int + count_bno_extents_blocks(xfs_agnumber_t agno, uint *numblocks) + { +- __uint64_t nblocks; ++ uint64_t nblocks; + extent_tree_node_t *node; + int i = 0; + +diff --git a/repair/incore_ino.c b/repair/incore_ino.c +index 2ec17657..3b6b44d4 100644 +--- a/repair/incore_ino.c ++++ b/repair/incore_ino.c +@@ -38,7 +38,7 @@ static avltree_desc_t **inode_uncertain_tree_ptrs; + /* memory optimised nlink counting for all inodes */ + + static void * +-alloc_nlink_array(__uint8_t nlink_size) ++alloc_nlink_array(uint8_t nlink_size) + { + void *ptr; + +@@ -51,10 +51,10 @@ alloc_nlink_array(__uint8_t nlink_size) + static void + nlink_grow_8_to_16(ino_tree_node_t *irec) + { +- __uint16_t *new_nlinks; ++ uint16_t *new_nlinks; + int i; + +- irec->nlink_size = sizeof(__uint16_t); ++ irec->nlink_size = sizeof(uint16_t); + + new_nlinks = alloc_nlink_array(irec->nlink_size); + for (i = 0; i < XFS_INODES_PER_CHUNK; i++) +@@ -76,10 +76,10 @@ nlink_grow_8_to_16(ino_tree_node_t *irec) + static void + nlink_grow_16_to_32(ino_tree_node_t *irec) + { +- __uint32_t *new_nlinks; ++ uint32_t *new_nlinks; + int i; + +- irec->nlink_size = sizeof(__uint32_t); ++ irec->nlink_size = sizeof(uint32_t); + + new_nlinks = alloc_nlink_array(irec->nlink_size); + for (i = 0; i < XFS_INODES_PER_CHUNK; i++) +@@ -104,21 +104,21 @@ void add_inode_ref(struct ino_tree_node *irec, int ino_offset) + ASSERT(irec->ino_un.ex_data != NULL); + + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + if (irec->ino_un.ex_data->counted_nlinks.un8[ino_offset] < 0xff) { + irec->ino_un.ex_data->counted_nlinks.un8[ino_offset]++; + break; + } + nlink_grow_8_to_16(irec); + /*FALLTHRU*/ +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + if (irec->ino_un.ex_data->counted_nlinks.un16[ino_offset] < 0xffff) { + irec->ino_un.ex_data->counted_nlinks.un16[ino_offset]++; + break; + } + nlink_grow_16_to_32(irec); + /*FALLTHRU*/ +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + irec->ino_un.ex_data->counted_nlinks.un32[ino_offset]++; + break; + default: +@@ -128,20 +128,20 @@ void add_inode_ref(struct ino_tree_node *irec, int ino_offset) + + void drop_inode_ref(struct ino_tree_node *irec, int ino_offset) + { +- __uint32_t refs = 0; ++ uint32_t refs = 0; + + ASSERT(irec->ino_un.ex_data != NULL); + + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + ASSERT(irec->ino_un.ex_data->counted_nlinks.un8[ino_offset] > 0); + refs = --irec->ino_un.ex_data->counted_nlinks.un8[ino_offset]; + break; +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + ASSERT(irec->ino_un.ex_data->counted_nlinks.un16[ino_offset] > 0); + refs = --irec->ino_un.ex_data->counted_nlinks.un16[ino_offset]; + break; +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + ASSERT(irec->ino_un.ex_data->counted_nlinks.un32[ino_offset] > 0); + refs = --irec->ino_un.ex_data->counted_nlinks.un32[ino_offset]; + break; +@@ -153,16 +153,16 @@ void drop_inode_ref(struct ino_tree_node *irec, int ino_offset) + irec->ino_un.ex_data->ino_reached &= ~IREC_MASK(ino_offset); + } + +-__uint32_t num_inode_references(struct ino_tree_node *irec, int ino_offset) ++uint32_t num_inode_references(struct ino_tree_node *irec, int ino_offset) + { + ASSERT(irec->ino_un.ex_data != NULL); + + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + return irec->ino_un.ex_data->counted_nlinks.un8[ino_offset]; +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + return irec->ino_un.ex_data->counted_nlinks.un16[ino_offset]; +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + return irec->ino_un.ex_data->counted_nlinks.un32[ino_offset]; + default: + ASSERT(0); +@@ -171,24 +171,24 @@ __uint32_t num_inode_references(struct ino_tree_node *irec, int ino_offset) + } + + void set_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset, +- __uint32_t nlinks) ++ uint32_t nlinks) + { + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + if (nlinks < 0xff) { + irec->disk_nlinks.un8[ino_offset] = nlinks; + break; + } + nlink_grow_8_to_16(irec); + /*FALLTHRU*/ +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + if (nlinks < 0xffff) { + irec->disk_nlinks.un16[ino_offset] = nlinks; + break; + } + nlink_grow_16_to_32(irec); + /*FALLTHRU*/ +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + irec->disk_nlinks.un32[ino_offset] = nlinks; + break; + default: +@@ -196,14 +196,14 @@ void set_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset, + } + } + +-__uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset) ++uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset) + { + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + return irec->disk_nlinks.un8[ino_offset]; +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + return irec->disk_nlinks.un16[ino_offset]; +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + return irec->disk_nlinks.un32[ino_offset]; + default: + ASSERT(0); +@@ -211,11 +211,11 @@ __uint32_t get_inode_disk_nlinks(struct ino_tree_node *irec, int ino_offset) + return 0; + } + +-static __uint8_t * ++static uint8_t * + alloc_ftypes_array( + struct xfs_mount *mp) + { +- __uint8_t *ptr; ++ uint8_t *ptr; + + if (!xfs_sb_version_hasftype(&mp->m_sb)) + return NULL; +@@ -262,23 +262,23 @@ alloc_ino_node( + irec->ir_free = (xfs_inofree_t) - 1; + irec->ir_sparse = 0; + irec->ino_un.ex_data = NULL; +- irec->nlink_size = sizeof(__uint8_t); ++ irec->nlink_size = sizeof(uint8_t); + irec->disk_nlinks.un8 = alloc_nlink_array(irec->nlink_size); + irec->ftypes = alloc_ftypes_array(mp); + return irec; + } + + static void +-free_nlink_array(union ino_nlink nlinks, __uint8_t nlink_size) ++free_nlink_array(union ino_nlink nlinks, uint8_t nlink_size) + { + switch (nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + free(nlinks.un8); + break; +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + free(nlinks.un16); + break; +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + free(nlinks.un32); + break; + default: +@@ -609,7 +609,7 @@ set_inode_parent( + int i; + int cnt; + int target; +- __uint64_t bitmask; ++ uint64_t bitmask; + parent_entry_t *tmp; + + if (full_ino_ex_data) +@@ -699,7 +699,7 @@ set_inode_parent( + xfs_ino_t + get_inode_parent(ino_tree_node_t *irec, int offset) + { +- __uint64_t bitmask; ++ uint64_t bitmask; + parent_list_t *ptbl; + int i; + int target; +@@ -740,15 +740,15 @@ alloc_ex_data(ino_tree_node_t *irec) + irec->ino_un.ex_data->parents = ptbl; + + switch (irec->nlink_size) { +- case sizeof(__uint8_t): ++ case sizeof(uint8_t): + irec->ino_un.ex_data->counted_nlinks.un8 = + alloc_nlink_array(irec->nlink_size); + break; +- case sizeof(__uint16_t): ++ case sizeof(uint16_t): + irec->ino_un.ex_data->counted_nlinks.un16 = + alloc_nlink_array(irec->nlink_size); + break; +- case sizeof(__uint32_t): ++ case sizeof(uint32_t): + irec->ino_un.ex_data->counted_nlinks.un32 = + alloc_nlink_array(irec->nlink_size); + break; +diff --git a/repair/phase2.c b/repair/phase2.c +index c21778b8..0085732b 100644 +--- a/repair/phase2.c ++++ b/repair/phase2.c +@@ -179,7 +179,7 @@ phase2( + + bad_ino_btree = 0; + +- set_progress_msg(PROG_FMT_SCAN_AG, (__uint64_t) glob_agcount); ++ set_progress_msg(PROG_FMT_SCAN_AG, (uint64_t) glob_agcount); + + scan_ags(mp, scan_threads); + +diff --git a/repair/phase3.c b/repair/phase3.c +index 0890a27d..17b1c28d 100644 +--- a/repair/phase3.c ++++ b/repair/phase3.c +@@ -122,7 +122,7 @@ phase3( + else + do_log(_(" - scan (but don't clear) agi unlinked lists...\n")); + +- set_progress_msg(PROG_FMT_AGI_UNLINKED, (__uint64_t) glob_agcount); ++ set_progress_msg(PROG_FMT_AGI_UNLINKED, (uint64_t) glob_agcount); + + /* first clear the agi unlinked AGI list */ + if (!no_modify) { +@@ -142,7 +142,7 @@ phase3( + do_log(_( + " - process known inodes and perform inode discovery...\n")); + +- set_progress_msg(PROG_FMT_PROCESS_INO, (__uint64_t) mp->m_sb.sb_icount); ++ set_progress_msg(PROG_FMT_PROCESS_INO, (uint64_t) mp->m_sb.sb_icount); + + process_ags(mp); + +@@ -152,7 +152,7 @@ phase3( + * process newly discovered inode chunks + */ + do_log(_(" - process newly discovered inodes...\n")); +- set_progress_msg(PROG_FMT_NEW_INODES, (__uint64_t) glob_agcount); ++ set_progress_msg(PROG_FMT_NEW_INODES, (uint64_t) glob_agcount); + + counts = calloc(sizeof(*counts), mp->m_sb.sb_agcount); + if (!counts) { +diff --git a/repair/phase4.c b/repair/phase4.c +index e59464b1..cc17ec03 100644 +--- a/repair/phase4.c ++++ b/repair/phase4.c +@@ -290,7 +290,7 @@ phase4(xfs_mount_t *mp) + do_log(_("Phase 4 - check for duplicate blocks...\n")); + do_log(_(" - setting up duplicate extent list...\n")); + +- set_progress_msg(PROG_FMT_DUP_EXTENT, (__uint64_t) glob_agcount); ++ set_progress_msg(PROG_FMT_DUP_EXTENT, (uint64_t) glob_agcount); + + irec = find_inode_rec(mp, XFS_INO_TO_AGNO(mp, mp->m_sb.sb_rootino), + XFS_INO_TO_AGINO(mp, mp->m_sb.sb_rootino)); +@@ -404,7 +404,7 @@ phase4(xfs_mount_t *mp) + reset_bmaps(mp); + + do_log(_(" - check for inodes claiming duplicate blocks...\n")); +- set_progress_msg(PROG_FMT_DUP_BLOCKS, (__uint64_t) mp->m_sb.sb_icount); ++ set_progress_msg(PROG_FMT_DUP_BLOCKS, (uint64_t) mp->m_sb.sb_icount); + + /* + * ok, now process the inodes -- signal 2-pass check per inode. +diff --git a/repair/phase5.c b/repair/phase5.c +index 0b833f13..21dce67a 100644 +--- a/repair/phase5.c ++++ b/repair/phase5.c +@@ -86,9 +86,9 @@ struct agi_stat { + xfs_agino_t freecount; + }; + +-static __uint64_t *sb_icount_ag; /* allocated inodes per ag */ +-static __uint64_t *sb_ifree_ag; /* free inodes per ag */ +-static __uint64_t *sb_fdblocks_ag; /* free data blocks per ag */ ++static uint64_t *sb_icount_ag; /* allocated inodes per ag */ ++static uint64_t *sb_ifree_ag; /* free inodes per ag */ ++static uint64_t *sb_fdblocks_ag; /* free data blocks per ag */ + + static int + mk_incore_fstree(xfs_mount_t *mp, xfs_agnumber_t agno) +@@ -886,10 +886,10 @@ build_freespace_tree(xfs_mount_t *mp, xfs_agnumber_t agno, + */ + static void + init_ino_cursor(xfs_mount_t *mp, xfs_agnumber_t agno, bt_status_t *btree_curs, +- __uint64_t *num_inos, __uint64_t *num_free_inos, int finobt) ++ uint64_t *num_inos, uint64_t *num_free_inos, int finobt) + { +- __uint64_t ninos; +- __uint64_t nfinos; ++ uint64_t ninos; ++ uint64_t nfinos; + int rec_nfinos; + int rec_ninos; + ino_tree_node_t *ino_rec; +@@ -2193,10 +2193,10 @@ phase5_func( + xfs_agnumber_t agno, + struct xfs_slab *lost_fsb) + { +- __uint64_t num_inos; +- __uint64_t num_free_inos; +- __uint64_t finobt_num_inos; +- __uint64_t finobt_num_free_inos; ++ uint64_t num_inos; ++ uint64_t num_free_inos; ++ uint64_t finobt_num_inos; ++ uint64_t finobt_num_free_inos; + bt_status_t bno_btree_curs; + bt_status_t bcnt_btree_curs; + bt_status_t ino_btree_curs; +@@ -2471,7 +2471,7 @@ phase5(xfs_mount_t *mp) + int error; + + do_log(_("Phase 5 - rebuild AG headers and trees...\n")); +- set_progress_msg(PROG_FMT_REBUILD_AG, (__uint64_t )glob_agcount); ++ set_progress_msg(PROG_FMT_REBUILD_AG, (uint64_t)glob_agcount); + + #ifdef XR_BLD_FREE_TRACE + fprintf(stderr, "inobt level 1, maxrec = %d, minrec = %d\n", +@@ -2497,15 +2497,15 @@ phase5(xfs_mount_t *mp) + keep_fsinos(mp); + + /* allocate per ag counters */ +- sb_icount_ag = calloc(mp->m_sb.sb_agcount, sizeof(__uint64_t)); ++ sb_icount_ag = calloc(mp->m_sb.sb_agcount, sizeof(uint64_t)); + if (sb_icount_ag == NULL) + do_error(_("cannot alloc sb_icount_ag buffers\n")); + +- sb_ifree_ag = calloc(mp->m_sb.sb_agcount, sizeof(__uint64_t)); ++ sb_ifree_ag = calloc(mp->m_sb.sb_agcount, sizeof(uint64_t)); + if (sb_ifree_ag == NULL) + do_error(_("cannot alloc sb_ifree_ag buffers\n")); + +- sb_fdblocks_ag = calloc(mp->m_sb.sb_agcount, sizeof(__uint64_t)); ++ sb_fdblocks_ag = calloc(mp->m_sb.sb_agcount, sizeof(uint64_t)); + if (sb_fdblocks_ag == NULL) + do_error(_("cannot alloc sb_fdblocks_ag buffers\n")); + +diff --git a/repair/phase6.c b/repair/phase6.c +index 08636dcf..373b1a5b 100644 +--- a/repair/phase6.c ++++ b/repair/phase6.c +@@ -82,7 +82,7 @@ typedef struct dir_hash_ent { + struct dir_hash_ent *nextbyhash; /* next in name bucket */ + struct dir_hash_ent *nextbyorder; /* next in order added */ + xfs_dahash_t hashval; /* hash value of name */ +- __uint32_t address; /* offset of data entry */ ++ uint32_t address; /* offset of data entry */ + xfs_ino_t inum; /* inode num of entry */ + short junkit; /* name starts with / */ + short seen; /* have seen leaf entry */ +@@ -170,11 +170,11 @@ static int + dir_hash_add( + xfs_mount_t *mp, + dir_hash_tab_t *hashtab, +- __uint32_t addr, ++ uint32_t addr, + xfs_ino_t inum, + int namelen, + unsigned char *name, +- __uint8_t ftype) ++ uint8_t ftype) + { + xfs_dahash_t hash = 0; + int byaddr; +@@ -357,7 +357,7 @@ static void + dir_hash_update_ftype( + dir_hash_tab_t *hashtab, + xfs_dir2_dataptr_t addr, +- __uint8_t ftype) ++ uint8_t ftype) + { + int i; + dir_hash_ent_t *p; +@@ -1791,8 +1791,8 @@ longform_dir2_entry_check_data( + + /* validate ftype field if supported */ + if (xfs_sb_version_hasftype(&mp->m_sb)) { +- __uint8_t dir_ftype; +- __uint8_t ino_ftype; ++ uint8_t dir_ftype; ++ uint8_t ino_ftype; + + dir_ftype = M_DIROPS(mp)->data_get_ftype(dep); + ino_ftype = get_inode_ftype(irec, ino_offset); +@@ -2703,8 +2703,8 @@ _("entry \"%s\" (ino %" PRIu64 ") in dir %" PRIu64 " is a duplicate name"), + + /* validate ftype field if supported */ + if (xfs_sb_version_hasftype(&mp->m_sb)) { +- __uint8_t dir_ftype; +- __uint8_t ino_ftype; ++ uint8_t dir_ftype; ++ uint8_t ino_ftype; + + dir_ftype = M_DIROPS(mp)->sf_get_ftype(sfep); + ino_ftype = get_inode_ftype(irec, ino_offset); +diff --git a/repair/phase7.c b/repair/phase7.c +index 8bce117d..4ffb81a8 100644 +--- a/repair/phase7.c ++++ b/repair/phase7.c +@@ -32,7 +32,7 @@ static void + update_inode_nlinks( + xfs_mount_t *mp, + xfs_ino_t ino, +- __uint32_t nlinks) ++ uint32_t nlinks) + { + xfs_trans_t *tp; + xfs_inode_t *ip; +@@ -104,7 +104,7 @@ do_link_updates( + { + ino_tree_node_t *irec; + int j; +- __uint32_t nrefs; ++ uint32_t nrefs; + + for (irec = findfirst_inode_rec(agno); irec; + irec = next_ino_rec(irec)) { +@@ -143,7 +143,7 @@ phase7( + else + do_log(_("Phase 7 - verify link counts...\n")); + +- set_progress_msg(PROGRESS_FMT_CORR_LINK, (__uint64_t) glob_agcount); ++ set_progress_msg(PROGRESS_FMT_CORR_LINK, (uint64_t) glob_agcount); + + create_work_queue(&wq, mp, scan_threads); + +diff --git a/repair/progress.c b/repair/progress.c +index 2a09b239..99d2658c 100644 +--- a/repair/progress.c ++++ b/repair/progress.c +@@ -85,8 +85,8 @@ pthread_t report_thread; + typedef struct msg_block_s { + pthread_mutex_t mutex; + progress_rpt_t *format; +- __uint64_t *done; +- __uint64_t *total; ++ uint64_t *done; ++ uint64_t *total; + int count; + int interval; + } msg_block_t; +@@ -96,14 +96,14 @@ typedef struct phase_times_s { + time_t start; + time_t end; + time_t duration; +- __uint64_t item_counts[4]; ++ uint64_t item_counts[4]; + } phase_times_t; + static phase_times_t phase_times[8]; + + static void *progress_rpt_thread(void *); + static int current_phase; + static int running; +-static __uint64_t prog_rpt_total; ++static uint64_t prog_rpt_total; + + void + init_progress_rpt (void) +@@ -113,11 +113,11 @@ init_progress_rpt (void) + * allocate the done vector + */ + +- if ((prog_rpt_done = (__uint64_t *) +- malloc(sizeof(__uint64_t)*glob_agcount)) == NULL ) { ++ if ((prog_rpt_done = (uint64_t *) ++ malloc(sizeof(uint64_t)*glob_agcount)) == NULL) { + do_error(_("cannot malloc pointer to done vector\n")); + } +- bzero(prog_rpt_done, sizeof(__uint64_t)*glob_agcount); ++ bzero(prog_rpt_done, sizeof(uint64_t)*glob_agcount); + + /* + * Setup comm block, start the thread +@@ -165,10 +165,10 @@ progress_rpt_thread (void *p) + timer_t timerid; + struct itimerspec timespec; + char *msgbuf; +- __uint64_t *donep; +- __uint64_t sum; ++ uint64_t *donep; ++ uint64_t sum; + msg_block_t *msgp = (msg_block_t *)p; +- __uint64_t percent; ++ uint64_t percent; + + /* It's possible to get here very early w/ no progress msg set */ + if (!msgp->format) +@@ -286,7 +286,7 @@ progress_rpt_thread (void *p) + } + + int +-set_progress_msg (int report, __uint64_t total) ++set_progress_msg(int report, uint64_t total) + { + + if (!ag_stride) +@@ -300,7 +300,7 @@ set_progress_msg (int report, __uint64_t total) + + /* reset all the accumulative totals */ + if (prog_rpt_done) +- bzero(prog_rpt_done, sizeof(__uint64_t)*glob_agcount); ++ bzero(prog_rpt_done, sizeof(uint64_t)*glob_agcount); + + if (pthread_mutex_unlock(&global_msgs.mutex)) + do_error(_("set_progress_msg: cannot unlock progress mutex\n")); +@@ -308,14 +308,14 @@ set_progress_msg (int report, __uint64_t total) + return (0); + } + +-__uint64_t ++uint64_t + print_final_rpt(void) + { + int i; + struct tm *tmp; + time_t now; +- __uint64_t *donep; +- __uint64_t sum; ++ uint64_t *donep; ++ uint64_t sum; + msg_block_t *msgp = &global_msgs; + char msgbuf[DURATION_BUF_SIZE]; + +diff --git a/repair/progress.h b/repair/progress.h +index 33db8344..51526483 100644 +--- a/repair/progress.h ++++ b/repair/progress.h +@@ -32,8 +32,8 @@ + extern void init_progress_rpt(void); + extern void stop_progress_rpt(void); + extern void summary_report(void); +-extern int set_progress_msg(int report, __uint64_t total); +-extern __uint64_t print_final_rpt(void); ++extern int set_progress_msg(int report, uint64_t total); ++extern uint64_t print_final_rpt(void); + extern char *timestamp(int end, int phase, char *buf); + extern char *duration(int val, char *buf); + extern int do_parallel; +diff --git a/repair/rmap.c b/repair/rmap.c +index ab6e5839..01d6f0fc 100644 +--- a/repair/rmap.c ++++ b/repair/rmap.c +@@ -343,7 +343,7 @@ err: + + static int + find_first_zero_bit( +- __uint64_t mask) ++ uint64_t mask) + { + int n; + int b = 0; +@@ -356,7 +356,7 @@ find_first_zero_bit( + + static int + popcnt( +- __uint64_t mask) ++ uint64_t mask) + { + int n; + int b = 0; +@@ -1064,14 +1064,14 @@ err: + * Compare the key fields of two rmap records -- positive if key1 > key2, + * negative if key1 < key2, and zero if equal. + */ +-__int64_t ++int64_t + rmap_diffkeys( + struct xfs_rmap_irec *kp1, + struct xfs_rmap_irec *kp2) + { + __u64 oa; + __u64 ob; +- __int64_t d; ++ int64_t d; + struct xfs_rmap_irec tmp; + + tmp = *kp1; +@@ -1081,7 +1081,7 @@ rmap_diffkeys( + tmp.rm_flags &= ~XFS_RMAP_REC_FLAGS; + ob = libxfs_rmap_irec_offset_pack(&tmp); + +- d = (__int64_t)kp1->rm_startblock - kp2->rm_startblock; ++ d = (int64_t)kp1->rm_startblock - kp2->rm_startblock; + if (d) + return d; + +@@ -1192,10 +1192,10 @@ fix_inode_reflink_flags( + { + struct ino_tree_node *irec; + int bit; +- __uint64_t was; +- __uint64_t is; +- __uint64_t diff; +- __uint64_t mask; ++ uint64_t was; ++ uint64_t is; ++ uint64_t diff; ++ uint64_t mask; + int error = 0; + xfs_agino_t agino; + +diff --git a/repair/rmap.h b/repair/rmap.h +index 752ece82..1616ab7d 100644 +--- a/repair/rmap.h ++++ b/repair/rmap.h +@@ -44,7 +44,7 @@ extern int rmap_init_cursor(xfs_agnumber_t, struct xfs_slab_cursor **); + extern void rmap_avoid_check(void); + extern int rmaps_verify_btree(struct xfs_mount *, xfs_agnumber_t); + +-extern __int64_t rmap_diffkeys(struct xfs_rmap_irec *kp1, ++extern int64_t rmap_diffkeys(struct xfs_rmap_irec *kp1, + struct xfs_rmap_irec *kp2); + extern void rmap_high_key_from_rec(struct xfs_rmap_irec *rec, + struct xfs_rmap_irec *key); +diff --git a/repair/sb.c b/repair/sb.c +index 77e51546..acc92839 100644 +--- a/repair/sb.c ++++ b/repair/sb.c +@@ -40,7 +40,7 @@ copy_sb(xfs_sb_t *source, xfs_sb_t *dest) + xfs_ino_t uquotino; + xfs_ino_t gquotino; + xfs_ino_t pquotino; +- __uint16_t versionnum; ++ uint16_t versionnum; + + rootino = dest->sb_rootino; + rbmino = dest->sb_rbmino; +@@ -106,8 +106,8 @@ verify_sb_blocksize(xfs_sb_t *sb) + static int + __find_secondary_sb( + xfs_sb_t *rsb, +- __uint64_t start, +- __uint64_t skip) ++ uint64_t start, ++ uint64_t skip) + { + xfs_off_t off; + xfs_sb_t *sb; +@@ -187,13 +187,13 @@ __find_secondary_sb( + + static int + guess_default_geometry( +- __uint64_t *agsize, +- __uint64_t *agcount, ++ uint64_t *agsize, ++ uint64_t *agcount, + libxfs_init_t *x) + { + struct fs_topology ft; + int blocklog; +- __uint64_t dblocks; ++ uint64_t dblocks; + int multidisk; + + memset(&ft, 0, sizeof(ft)); +@@ -216,9 +216,9 @@ int + find_secondary_sb(xfs_sb_t *rsb) + { + int retval = 0; +- __uint64_t agcount; +- __uint64_t agsize; +- __uint64_t skip; ++ uint64_t agcount; ++ uint64_t agsize; ++ uint64_t skip; + int blocklog; + + /* +@@ -229,7 +229,7 @@ find_secondary_sb(xfs_sb_t *rsb) + do_warn(_("\nattempting to find secondary superblock...\n")); + + if (verify_sb_blocksize(rsb) == 0) { +- skip = (__uint64_t)rsb->sb_agblocks * rsb->sb_blocksize; ++ skip = (uint64_t)rsb->sb_agblocks * rsb->sb_blocksize; + if (skip >= XFS_AG_MIN_BYTES && skip <= XFS_AG_MAX_BYTES) + retval = __find_secondary_sb(rsb, skip, skip); + } +@@ -343,7 +343,7 @@ sb_validate_ino_align(struct xfs_sb *sb) + int + verify_sb(char *sb_buf, xfs_sb_t *sb, int is_primary_sb) + { +- __uint32_t bsize; ++ uint32_t bsize; + int i; + int ret; + +@@ -399,7 +399,7 @@ verify_sb(char *sb_buf, xfs_sb_t *sb, int is_primary_sb) + sb->sb_dblocks < XFS_MIN_DBLOCKS(sb)) + return(XR_BAD_FS_SIZE_DATA); + +- if (sb->sb_agblklog != (__uint8_t)libxfs_log2_roundup(sb->sb_agblocks)) ++ if (sb->sb_agblklog != (uint8_t)libxfs_log2_roundup(sb->sb_agblocks)) + return(XR_BAD_FS_SIZE_DATA); + + if (sb->sb_inodesize < XFS_DINODE_MIN_SIZE || +diff --git a/repair/scan.c b/repair/scan.c +index b9ef4dc3..447611ac 100644 +--- a/repair/scan.c ++++ b/repair/scan.c +@@ -42,13 +42,13 @@ struct aghdr_cnts { + xfs_agnumber_t agno; + xfs_extlen_t agffreeblks; + xfs_extlen_t agflongest; +- __uint64_t agfbtreeblks; +- __uint32_t agicount; +- __uint32_t agifreecount; +- __uint64_t fdblocks; +- __uint64_t usedblocks; +- __uint64_t ifreecount; +- __uint32_t fibtfreecount; ++ uint64_t agfbtreeblks; ++ uint32_t agicount; ++ uint32_t agifreecount; ++ uint64_t fdblocks; ++ uint64_t usedblocks; ++ uint64_t ifreecount; ++ uint32_t fibtfreecount; + }; + + void +@@ -70,10 +70,10 @@ scan_sbtree( + xfs_agnumber_t agno, + int suspect, + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv), + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv, + const struct xfs_buf_ops *ops) + { +@@ -110,23 +110,23 @@ scan_lbtree( + xfs_fsblock_t bno, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + blkmap_t **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, + int *dirty, +- __uint64_t magic), ++ uint64_t magic), + int type, + int whichfork, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + blkmap_t **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, +- __uint64_t magic, ++ uint64_t magic, + const struct xfs_buf_ops *ops) + { + xfs_buf_t *bp; +@@ -179,13 +179,13 @@ scan_bmapbt( + xfs_fsblock_t bno, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + blkmap_t **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, + int *dirty, +- __uint64_t magic) ++ uint64_t magic) + { + int i; + int err; +@@ -548,7 +548,7 @@ scan_allocbt( + xfs_agnumber_t agno, + int suspect, + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv) + { + struct aghdr_cnts *agcnts = priv; +@@ -930,7 +930,7 @@ scan_rmapbt( + xfs_agnumber_t agno, + int suspect, + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv) + { + const char *name = "rmap"; +@@ -1233,7 +1233,7 @@ scan_refcbt( + xfs_agnumber_t agno, + int suspect, + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv) + { + const char *name = "refcount"; +@@ -1939,7 +1939,7 @@ scan_inobt( + xfs_agnumber_t agno, + int suspect, + int isroot, +- __uint32_t magic, ++ uint32_t magic, + void *priv) + { + struct aghdr_cnts *agcnts = priv; +@@ -2176,7 +2176,7 @@ validate_agf( + struct aghdr_cnts *agcnts) + { + xfs_agblock_t bno; +- __uint32_t magic; ++ uint32_t magic; + + bno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNO]); + if (bno != 0 && verify_agbno(mp, agno, bno)) { +@@ -2274,7 +2274,7 @@ validate_agi( + { + xfs_agblock_t bno; + int i; +- __uint32_t magic; ++ uint32_t magic; + + bno = be32_to_cpu(agi->agi_root); + if (bno != 0 && verify_agbno(mp, agno, bno)) { +@@ -2499,10 +2499,10 @@ scan_ags( + int scan_threads) + { + struct aghdr_cnts *agcnts; +- __uint64_t fdblocks = 0; +- __uint64_t icount = 0; +- __uint64_t ifreecount = 0; +- __uint64_t usedblocks = 0; ++ uint64_t fdblocks = 0; ++ uint64_t icount = 0; ++ uint64_t ifreecount = 0; ++ uint64_t usedblocks = 0; + xfs_agnumber_t i; + work_queue_t wq; + +diff --git a/repair/scan.h b/repair/scan.h +index ea8c0bf2..9bbe1e69 100644 +--- a/repair/scan.h ++++ b/repair/scan.h +@@ -30,23 +30,23 @@ int scan_lbtree( + xfs_fsblock_t bno, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + struct blkmap **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, + int *dirty, +- __uint64_t magic), ++ uint64_t magic), + int type, + int whichfork, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + struct blkmap **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, +- __uint64_t magic, ++ uint64_t magic, + const struct xfs_buf_ops *ops); + + int scan_bmapbt( +@@ -57,13 +57,13 @@ int scan_bmapbt( + xfs_fsblock_t bno, + xfs_ino_t ino, + xfs_rfsblock_t *tot, +- __uint64_t *nex, ++ uint64_t *nex, + struct blkmap **blkmapp, + bmap_cursor_t *bm_cursor, + int isroot, + int check_dups, + int *dirty, +- __uint64_t magic); ++ uint64_t magic); + + void + scan_ags( +-- +2.14.1 + diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-remaining-double-underscore-integer-.patch b/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-remaining-double-underscore-integer-.patch new file mode 100644 index 000000000..158c504f0 --- /dev/null +++ b/meta-filesystems/recipes-utils/xfsprogs/files/0001-xfsprogs-remove-remaining-double-underscore-integer-.patch @@ -0,0 +1,2046 @@ +From 2c21990918ba409a032c123d43ad5edef7981006 Mon Sep 17 00:00:00 2001 +From: Khem Raj +Date: Fri, 8 Sep 2017 18:46:55 -0700 +Subject: [PATCH] xfsprogs: remove remaining double-underscore integer types + + This is a purely mechanical patch that removes the private + __{u,}int{8,16,32,64}_t use in favor of using the system + provided {u,}int{8,16,32,64}_t typedefs. + +Signed-off-by: Khem Raj +--- + libxfs/xfs_alloc_btree.c | 20 ++-- + libxfs/xfs_attr_remote.c | 8 +- + libxfs/xfs_attr_sf.h | 10 +- + libxfs/xfs_bit.h | 24 ++--- + libxfs/xfs_bmap_btree.c | 8 +- + libxfs/xfs_btree.c | 22 ++-- + libxfs/xfs_btree.h | 18 ++-- + libxfs/xfs_cksum.h | 16 +-- + libxfs/xfs_da_btree.c | 2 +- + libxfs/xfs_da_btree.h | 8 +- + libxfs/xfs_da_format.c | 28 ++--- + libxfs/xfs_da_format.h | 64 +++++------ + libxfs/xfs_dir2.h | 8 +- + libxfs/xfs_dir2_leaf.c | 12 +-- + libxfs/xfs_dir2_priv.h | 2 +- + libxfs/xfs_dir2_sf.c | 2 +- + libxfs/xfs_format.h | 112 +++++++++---------- + libxfs/xfs_fs.h | 12 +-- + libxfs/xfs_ialloc.c | 6 +- + libxfs/xfs_ialloc_btree.c | 4 +- + libxfs/xfs_inode_buf.c | 2 +- + libxfs/xfs_inode_buf.h | 28 ++--- + libxfs/xfs_log_format.h | 256 ++++++++++++++++++++++---------------------- + libxfs/xfs_quota_defs.h | 4 +- + libxfs/xfs_refcount_btree.c | 8 +- + libxfs/xfs_rmap.c | 8 +- + libxfs/xfs_rmap.h | 8 +- + libxfs/xfs_rmap_btree.c | 30 +++--- + libxfs/xfs_rtbitmap.c | 2 +- + libxfs/xfs_sb.c | 4 +- + libxfs/xfs_types.h | 46 ++++---- + 31 files changed, 391 insertions(+), 391 deletions(-) + +diff --git a/libxfs/xfs_alloc_btree.c b/libxfs/xfs_alloc_btree.c +index e11d89a..c88b03b 100644 +--- a/libxfs/xfs_alloc_btree.c ++++ b/libxfs/xfs_alloc_btree.c +@@ -251,7 +251,7 @@ xfs_allocbt_init_ptr_from_cur( + ptr->s = agf->agf_roots[cur->bc_btnum]; + } + +-STATIC __int64_t ++STATIC int64_t + xfs_bnobt_key_diff( + struct xfs_btree_cur *cur, + union xfs_btree_key *key) +@@ -259,42 +259,42 @@ xfs_bnobt_key_diff( + xfs_alloc_rec_incore_t *rec = &cur->bc_rec.a; + xfs_alloc_key_t *kp = &key->alloc; + +- return (__int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock; ++ return (int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock; + } + +-STATIC __int64_t ++STATIC int64_t + xfs_cntbt_key_diff( + struct xfs_btree_cur *cur, + union xfs_btree_key *key) + { + xfs_alloc_rec_incore_t *rec = &cur->bc_rec.a; + xfs_alloc_key_t *kp = &key->alloc; +- __int64_t diff; ++ int64_t diff; + +- diff = (__int64_t)be32_to_cpu(kp->ar_blockcount) - rec->ar_blockcount; ++ diff = (int64_t)be32_to_cpu(kp->ar_blockcount) - rec->ar_blockcount; + if (diff) + return diff; + +- return (__int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock; ++ return (int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock; + } + +-STATIC __int64_t ++STATIC int64_t + xfs_bnobt_diff_two_keys( + struct xfs_btree_cur *cur, + union xfs_btree_key *k1, + union xfs_btree_key *k2) + { +- return (__int64_t)be32_to_cpu(k1->alloc.ar_startblock) - ++ return (int64_t)be32_to_cpu(k1->alloc.ar_startblock) - + be32_to_cpu(k2->alloc.ar_startblock); + } + +-STATIC __int64_t ++STATIC int64_t + xfs_cntbt_diff_two_keys( + struct xfs_btree_cur *cur, + union xfs_btree_key *k1, + union xfs_btree_key *k2) + { +- __int64_t diff; ++ int64_t diff; + + diff = be32_to_cpu(k1->alloc.ar_blockcount) - + be32_to_cpu(k2->alloc.ar_blockcount); +diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c +index abe1705..1f25e36 100644 +--- a/libxfs/xfs_attr_remote.c ++++ b/libxfs/xfs_attr_remote.c +@@ -248,7 +248,7 @@ xfs_attr_rmtval_copyout( + xfs_ino_t ino, + int *offset, + int *valuelen, +- __uint8_t **dst) ++ uint8_t **dst) + { + char *src = bp->b_addr; + xfs_daddr_t bno = bp->b_bn; +@@ -296,7 +296,7 @@ xfs_attr_rmtval_copyin( + xfs_ino_t ino, + int *offset, + int *valuelen, +- __uint8_t **src) ++ uint8_t **src) + { + char *dst = bp->b_addr; + xfs_daddr_t bno = bp->b_bn; +@@ -350,7 +350,7 @@ xfs_attr_rmtval_get( + struct xfs_mount *mp = args->dp->i_mount; + struct xfs_buf *bp; + xfs_dablk_t lblkno = args->rmtblkno; +- __uint8_t *dst = args->value; ++ uint8_t *dst = args->value; + int valuelen; + int nmap; + int error; +@@ -416,7 +416,7 @@ xfs_attr_rmtval_set( + struct xfs_bmbt_irec map; + xfs_dablk_t lblkno; + xfs_fileoff_t lfileoff = 0; +- __uint8_t *src = args->value; ++ uint8_t *src = args->value; + int blkcnt; + int valuelen; + int nmap; +diff --git a/libxfs/xfs_attr_sf.h b/libxfs/xfs_attr_sf.h +index 90928bb..b80dd33 100644 +--- a/libxfs/xfs_attr_sf.h ++++ b/libxfs/xfs_attr_sf.h +@@ -31,10 +31,10 @@ typedef struct xfs_attr_sf_entry xfs_attr_sf_entry_t; + * We generate this then sort it, attr_list() must return things in hash-order. + */ + typedef struct xfs_attr_sf_sort { +- __uint8_t entno; /* entry number in original list */ +- __uint8_t namelen; /* length of name value (no null) */ +- __uint8_t valuelen; /* length of value */ +- __uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */ ++ uint8_t entno; /* entry number in original list */ ++ uint8_t namelen; /* length of name value (no null) */ ++ uint8_t valuelen; /* length of value */ ++ uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */ + xfs_dahash_t hash; /* this entry's hash value */ + unsigned char *name; /* name value, pointer into buffer */ + } xfs_attr_sf_sort_t; +@@ -42,7 +42,7 @@ typedef struct xfs_attr_sf_sort { + #define XFS_ATTR_SF_ENTSIZE_BYNAME(nlen,vlen) /* space name/value uses */ \ + (((int)sizeof(xfs_attr_sf_entry_t)-1 + (nlen)+(vlen))) + #define XFS_ATTR_SF_ENTSIZE_MAX /* max space for name&value */ \ +- ((1 << (NBBY*(int)sizeof(__uint8_t))) - 1) ++ ((1 << (NBBY*(int)sizeof(uint8_t))) - 1) + #define XFS_ATTR_SF_ENTSIZE(sfep) /* space an entry uses */ \ + ((int)sizeof(xfs_attr_sf_entry_t)-1 + (sfep)->namelen+(sfep)->valuelen) + #define XFS_ATTR_SF_NEXTENTRY(sfep) /* next entry in struct */ \ +diff --git a/libxfs/xfs_bit.h b/libxfs/xfs_bit.h +index e1649c0..61c6b20 100644 +--- a/libxfs/xfs_bit.h ++++ b/libxfs/xfs_bit.h +@@ -25,47 +25,47 @@ + /* + * masks with n high/low bits set, 64-bit values + */ +-static inline __uint64_t xfs_mask64hi(int n) ++static inline uint64_t xfs_mask64hi(int n) + { +- return (__uint64_t)-1 << (64 - (n)); ++ return (uint64_t)-1 << (64 - (n)); + } +-static inline __uint32_t xfs_mask32lo(int n) ++static inline uint32_t xfs_mask32lo(int n) + { +- return ((__uint32_t)1 << (n)) - 1; ++ return ((uint32_t)1 << (n)) - 1; + } +-static inline __uint64_t xfs_mask64lo(int n) ++static inline uint64_t xfs_mask64lo(int n) + { +- return ((__uint64_t)1 << (n)) - 1; ++ return ((uint64_t)1 << (n)) - 1; + } + + /* Get high bit set out of 32-bit argument, -1 if none set */ +-static inline int xfs_highbit32(__uint32_t v) ++static inline int xfs_highbit32(uint32_t v) + { + return fls(v) - 1; + } + + /* Get high bit set out of 64-bit argument, -1 if none set */ +-static inline int xfs_highbit64(__uint64_t v) ++static inline int xfs_highbit64(uint64_t v) + { + return fls64(v) - 1; + } + + /* Get low bit set out of 32-bit argument, -1 if none set */ +-static inline int xfs_lowbit32(__uint32_t v) ++static inline int xfs_lowbit32(uint32_t v) + { + return ffs(v) - 1; + } + + /* Get low bit set out of 64-bit argument, -1 if none set */ +-static inline int xfs_lowbit64(__uint64_t v) ++static inline int xfs_lowbit64(uint64_t v) + { +- __uint32_t w = (__uint32_t)v; ++ uint32_t w = (uint32_t)v; + int n = 0; + + if (w) { /* lower bits */ + n = ffs(w); + } else { /* upper bits */ +- w = (__uint32_t)(v >> 32); ++ w = (uint32_t)(v >> 32); + if (w) { + n = ffs(w); + if (n) +diff --git a/libxfs/xfs_bmap_btree.c b/libxfs/xfs_bmap_btree.c +index c48cbec..9ee40d8 100644 +--- a/libxfs/xfs_bmap_btree.c ++++ b/libxfs/xfs_bmap_btree.c +@@ -91,8 +91,8 @@ xfs_bmdr_to_bmbt( + */ + STATIC void + __xfs_bmbt_get_all( +- __uint64_t l0, +- __uint64_t l1, ++ uint64_t l0, ++ uint64_t l1, + xfs_bmbt_irec_t *s) + { + int ext_flag; +@@ -585,12 +585,12 @@ xfs_bmbt_init_ptr_from_cur( + ptr->l = 0; + } + +-STATIC __int64_t ++STATIC int64_t + xfs_bmbt_key_diff( + struct xfs_btree_cur *cur, + union xfs_btree_key *key) + { +- return (__int64_t)be64_to_cpu(key->bmbt.br_startoff) - ++ return (int64_t)be64_to_cpu(key->bmbt.br_startoff) - + cur->bc_rec.b.br_startoff; + } + +diff --git a/libxfs/xfs_btree.c b/libxfs/xfs_btree.c +index 33bf0db..9c6d8e3 100644 +--- a/libxfs/xfs_btree.c ++++ b/libxfs/xfs_btree.c +@@ -39,7 +39,7 @@ kmem_zone_t *xfs_btree_cur_zone; + /* + * Btree magic numbers. + */ +-static const __uint32_t xfs_magics[2][XFS_BTNUM_MAX] = { ++static const uint32_t xfs_magics[2][XFS_BTNUM_MAX] = { + { XFS_ABTB_MAGIC, XFS_ABTC_MAGIC, 0, XFS_BMAP_MAGIC, XFS_IBT_MAGIC, + XFS_FIBT_MAGIC, 0 }, + { XFS_ABTB_CRC_MAGIC, XFS_ABTC_CRC_MAGIC, XFS_RMAP_CRC_MAGIC, +@@ -47,12 +47,12 @@ static const __uint32_t xfs_magics[2][XFS_BTNUM_MAX] = { + XFS_REFC_CRC_MAGIC } + }; + +-__uint32_t ++uint32_t + xfs_btree_magic( + int crc, + xfs_btnum_t btnum) + { +- __uint32_t magic = xfs_magics[crc][btnum]; ++ uint32_t magic = xfs_magics[crc][btnum]; + + /* Ensure we asked for crc for crc-only magics. */ + ASSERT(magic != 0); +@@ -774,14 +774,14 @@ xfs_btree_lastrec( + */ + void + xfs_btree_offsets( +- __int64_t fields, /* bitmask of fields */ ++ int64_t fields, /* bitmask of fields */ + const short *offsets, /* table of field offsets */ + int nbits, /* number of bits to inspect */ + int *first, /* output: first byte offset */ + int *last) /* output: last byte offset */ + { + int i; /* current bit number */ +- __int64_t imask; /* mask for current bit number */ ++ int64_t imask; /* mask for current bit number */ + + ASSERT(fields != 0); + /* +@@ -1842,7 +1842,7 @@ xfs_btree_lookup( + int *stat) /* success/failure */ + { + struct xfs_btree_block *block; /* current btree block */ +- __int64_t diff; /* difference for the current key */ ++ int64_t diff; /* difference for the current key */ + int error; /* error return value */ + int keyno; /* current key number */ + int level; /* level in the btree */ +@@ -4435,7 +4435,7 @@ xfs_btree_visit_blocks( + * recovery completion writes the changes to disk. + */ + struct xfs_btree_block_change_owner_info { +- __uint64_t new_owner; ++ uint64_t new_owner; + struct list_head *buffer_list; + }; + +@@ -4481,7 +4481,7 @@ xfs_btree_block_change_owner( + int + xfs_btree_change_owner( + struct xfs_btree_cur *cur, +- __uint64_t new_owner, ++ uint64_t new_owner, + struct list_head *buffer_list) + { + struct xfs_btree_block_change_owner_info bbcoi; +@@ -4585,7 +4585,7 @@ xfs_btree_simple_query_range( + { + union xfs_btree_rec *recp; + union xfs_btree_key rec_key; +- __int64_t diff; ++ int64_t diff; + int stat; + bool firstrec = true; + int error; +@@ -4682,8 +4682,8 @@ xfs_btree_overlapped_query_range( + union xfs_btree_key *hkp; + union xfs_btree_rec *recp; + struct xfs_btree_block *block; +- __int64_t ldiff; +- __int64_t hdiff; ++ int64_t ldiff; ++ int64_t hdiff; + int level; + struct xfs_buf *bp; + int i; +diff --git a/libxfs/xfs_btree.h b/libxfs/xfs_btree.h +index 05cf35b..3c1fed2 100644 +--- a/libxfs/xfs_btree.h ++++ b/libxfs/xfs_btree.h +@@ -76,7 +76,7 @@ union xfs_btree_rec { + #define XFS_BTNUM_RMAP ((xfs_btnum_t)XFS_BTNUM_RMAPi) + #define XFS_BTNUM_REFC ((xfs_btnum_t)XFS_BTNUM_REFCi) + +-__uint32_t xfs_btree_magic(int crc, xfs_btnum_t btnum); ++uint32_t xfs_btree_magic(int crc, xfs_btnum_t btnum); + + /* + * For logging record fields. +@@ -150,14 +150,14 @@ struct xfs_btree_ops { + union xfs_btree_rec *rec); + + /* difference between key value and cursor value */ +- __int64_t (*key_diff)(struct xfs_btree_cur *cur, ++ int64_t (*key_diff)(struct xfs_btree_cur *cur, + union xfs_btree_key *key); + + /* + * Difference between key2 and key1 -- positive if key1 > key2, + * negative if key1 < key2, and zero if equal. + */ +- __int64_t (*diff_two_keys)(struct xfs_btree_cur *cur, ++ int64_t (*diff_two_keys)(struct xfs_btree_cur *cur, + union xfs_btree_key *key1, + union xfs_btree_key *key2); + +@@ -213,11 +213,11 @@ typedef struct xfs_btree_cur + union xfs_btree_irec bc_rec; /* current insert/search record value */ + struct xfs_buf *bc_bufs[XFS_BTREE_MAXLEVELS]; /* buf ptr per level */ + int bc_ptrs[XFS_BTREE_MAXLEVELS]; /* key/record # */ +- __uint8_t bc_ra[XFS_BTREE_MAXLEVELS]; /* readahead bits */ ++ uint8_t bc_ra[XFS_BTREE_MAXLEVELS]; /* readahead bits */ + #define XFS_BTCUR_LEFTRA 1 /* left sibling has been read-ahead */ + #define XFS_BTCUR_RIGHTRA 2 /* right sibling has been read-ahead */ +- __uint8_t bc_nlevels; /* number of levels in the tree */ +- __uint8_t bc_blocklog; /* log2(blocksize) of btree blocks */ ++ uint8_t bc_nlevels; /* number of levels in the tree */ ++ uint8_t bc_blocklog; /* log2(blocksize) of btree blocks */ + xfs_btnum_t bc_btnum; /* identifies which btree type */ + int bc_statoff; /* offset of btre stats array */ + union { +@@ -330,7 +330,7 @@ xfs_btree_islastblock( + */ + void + xfs_btree_offsets( +- __int64_t fields, /* bitmask of fields */ ++ int64_t fields, /* bitmask of fields */ + const short *offsets,/* table of field offsets */ + int nbits, /* number of bits to inspect */ + int *first, /* output: first byte offset */ +@@ -408,7 +408,7 @@ int xfs_btree_new_iroot(struct xfs_btree_cur *, int *, int *); + int xfs_btree_insert(struct xfs_btree_cur *, int *); + int xfs_btree_delete(struct xfs_btree_cur *, int *); + int xfs_btree_get_rec(struct xfs_btree_cur *, union xfs_btree_rec **, int *); +-int xfs_btree_change_owner(struct xfs_btree_cur *cur, __uint64_t new_owner, ++int xfs_btree_change_owner(struct xfs_btree_cur *cur, uint64_t new_owner, + struct list_head *buffer_list); + + /* +@@ -434,7 +434,7 @@ static inline int xfs_btree_get_numrecs(struct xfs_btree_block *block) + } + + static inline void xfs_btree_set_numrecs(struct xfs_btree_block *block, +- __uint16_t numrecs) ++ uint16_t numrecs) + { + block->bb_numrecs = cpu_to_be16(numrecs); + } +diff --git a/libxfs/xfs_cksum.h b/libxfs/xfs_cksum.h +index a416c7c..8211f48 100644 +--- a/libxfs/xfs_cksum.h ++++ b/libxfs/xfs_cksum.h +@@ -1,7 +1,7 @@ + #ifndef _XFS_CKSUM_H + #define _XFS_CKSUM_H 1 + +-#define XFS_CRC_SEED (~(__uint32_t)0) ++#define XFS_CRC_SEED (~(uint32_t)0) + + /* + * Calculate the intermediate checksum for a buffer that has the CRC field +@@ -9,11 +9,11 @@ + * cksum_offset parameter. We do not modify the buffer during verification, + * hence we have to split the CRC calculation across the cksum_offset. + */ +-static inline __uint32_t ++static inline uint32_t + xfs_start_cksum_safe(char *buffer, size_t length, unsigned long cksum_offset) + { +- __uint32_t zero = 0; +- __uint32_t crc; ++ uint32_t zero = 0; ++ uint32_t crc; + + /* Calculate CRC up to the checksum. */ + crc = crc32c(XFS_CRC_SEED, buffer, cksum_offset); +@@ -30,7 +30,7 @@ xfs_start_cksum_safe(char *buffer, size_t length, unsigned long cksum_offset) + * Fast CRC method where the buffer is modified. Callers must have exclusive + * access to the buffer while the calculation takes place. + */ +-static inline __uint32_t ++static inline uint32_t + xfs_start_cksum_update(char *buffer, size_t length, unsigned long cksum_offset) + { + /* zero the CRC field */ +@@ -48,7 +48,7 @@ xfs_start_cksum_update(char *buffer, size_t length, unsigned long cksum_offset) + * so that it is consistent on disk. + */ + static inline __le32 +-xfs_end_cksum(__uint32_t crc) ++xfs_end_cksum(uint32_t crc) + { + return ~cpu_to_le32(crc); + } +@@ -62,7 +62,7 @@ xfs_end_cksum(__uint32_t crc) + static inline void + xfs_update_cksum(char *buffer, size_t length, unsigned long cksum_offset) + { +- __uint32_t crc = xfs_start_cksum_update(buffer, length, cksum_offset); ++ uint32_t crc = xfs_start_cksum_update(buffer, length, cksum_offset); + + *(__le32 *)(buffer + cksum_offset) = xfs_end_cksum(crc); + } +@@ -73,7 +73,7 @@ xfs_update_cksum(char *buffer, size_t length, unsigned long cksum_offset) + static inline int + xfs_verify_cksum(char *buffer, size_t length, unsigned long cksum_offset) + { +- __uint32_t crc = xfs_start_cksum_safe(buffer, length, cksum_offset); ++ uint32_t crc = xfs_start_cksum_safe(buffer, length, cksum_offset); + + return *(__le32 *)(buffer + cksum_offset) == xfs_end_cksum(crc); + } +diff --git a/libxfs/xfs_da_btree.c b/libxfs/xfs_da_btree.c +index bc12f58..08447be 100644 +--- a/libxfs/xfs_da_btree.c ++++ b/libxfs/xfs_da_btree.c +@@ -1947,7 +1947,7 @@ xfs_da3_path_shift( + * This is implemented with some source-level loop unrolling. + */ + xfs_dahash_t +-xfs_da_hashname(const __uint8_t *name, int namelen) ++xfs_da_hashname(const uint8_t *name, int namelen) + { + xfs_dahash_t hash; + +diff --git a/libxfs/xfs_da_btree.h b/libxfs/xfs_da_btree.h +index 4e29cb6..e08a05f 100644 +--- a/libxfs/xfs_da_btree.h ++++ b/libxfs/xfs_da_btree.h +@@ -60,10 +60,10 @@ enum xfs_dacmp { + */ + typedef struct xfs_da_args { + struct xfs_da_geometry *geo; /* da block geometry */ +- const __uint8_t *name; /* string (maybe not NULL terminated) */ ++ const uint8_t *name; /* string (maybe not NULL terminated) */ + int namelen; /* length of string (maybe no NULL) */ +- __uint8_t filetype; /* filetype of inode for directories */ +- __uint8_t *value; /* set of bytes (maybe contain NULLs) */ ++ uint8_t filetype; /* filetype of inode for directories */ ++ uint8_t *value; /* set of bytes (maybe contain NULLs) */ + int valuelen; /* length of value */ + int flags; /* argument flags (eg: ATTR_NOCREATE) */ + xfs_dahash_t hashval; /* hash value of name */ +@@ -207,7 +207,7 @@ int xfs_da_reada_buf(struct xfs_inode *dp, xfs_dablk_t bno, + int xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno, + struct xfs_buf *dead_buf); + +-uint xfs_da_hashname(const __uint8_t *name_string, int name_length); ++uint xfs_da_hashname(const uint8_t *name_string, int name_length); + enum xfs_dacmp xfs_da_compname(struct xfs_da_args *args, + const unsigned char *name, int len); + +diff --git a/libxfs/xfs_da_format.c b/libxfs/xfs_da_format.c +index 2b732b3..20cdc96 100644 +--- a/libxfs/xfs_da_format.c ++++ b/libxfs/xfs_da_format.c +@@ -49,7 +49,7 @@ xfs_dir3_sf_entsize( + struct xfs_dir2_sf_hdr *hdr, + int len) + { +- return xfs_dir2_sf_entsize(hdr, len) + sizeof(__uint8_t); ++ return xfs_dir2_sf_entsize(hdr, len) + sizeof(uint8_t); + } + + static struct xfs_dir2_sf_entry * +@@ -77,7 +77,7 @@ xfs_dir3_sf_nextentry( + * not necessary. For non-filetype enable directories, the type is always + * unknown and we never store the value. + */ +-static __uint8_t ++static uint8_t + xfs_dir2_sfe_get_ftype( + struct xfs_dir2_sf_entry *sfep) + { +@@ -87,16 +87,16 @@ xfs_dir2_sfe_get_ftype( + static void + xfs_dir2_sfe_put_ftype( + struct xfs_dir2_sf_entry *sfep, +- __uint8_t ftype) ++ uint8_t ftype) + { + ASSERT(ftype < XFS_DIR3_FT_MAX); + } + +-static __uint8_t ++static uint8_t + xfs_dir3_sfe_get_ftype( + struct xfs_dir2_sf_entry *sfep) + { +- __uint8_t ftype; ++ uint8_t ftype; + + ftype = sfep->name[sfep->namelen]; + if (ftype >= XFS_DIR3_FT_MAX) +@@ -107,7 +107,7 @@ xfs_dir3_sfe_get_ftype( + static void + xfs_dir3_sfe_put_ftype( + struct xfs_dir2_sf_entry *sfep, +- __uint8_t ftype) ++ uint8_t ftype) + { + ASSERT(ftype < XFS_DIR3_FT_MAX); + +@@ -124,7 +124,7 @@ xfs_dir3_sfe_put_ftype( + static xfs_ino_t + xfs_dir2_sf_get_ino( + struct xfs_dir2_sf_hdr *hdr, +- __uint8_t *from) ++ uint8_t *from) + { + if (hdr->i8count) + return get_unaligned_be64(from) & 0x00ffffffffffffffULL; +@@ -135,7 +135,7 @@ xfs_dir2_sf_get_ino( + static void + xfs_dir2_sf_put_ino( + struct xfs_dir2_sf_hdr *hdr, +- __uint8_t *to, ++ uint8_t *to, + xfs_ino_t ino) + { + ASSERT((ino & 0xff00000000000000ULL) == 0); +@@ -225,7 +225,7 @@ xfs_dir3_sfe_put_ino( + + #define XFS_DIR3_DATA_ENTSIZE(n) \ + round_up((offsetof(struct xfs_dir2_data_entry, name[0]) + (n) + \ +- sizeof(xfs_dir2_data_off_t) + sizeof(__uint8_t)), \ ++ sizeof(xfs_dir2_data_off_t) + sizeof(uint8_t)), \ + XFS_DIR2_DATA_ALIGN) + + static int +@@ -242,7 +242,7 @@ xfs_dir3_data_entsize( + return XFS_DIR3_DATA_ENTSIZE(n); + } + +-static __uint8_t ++static uint8_t + xfs_dir2_data_get_ftype( + struct xfs_dir2_data_entry *dep) + { +@@ -252,16 +252,16 @@ xfs_dir2_data_get_ftype( + static void + xfs_dir2_data_put_ftype( + struct xfs_dir2_data_entry *dep, +- __uint8_t ftype) ++ uint8_t ftype) + { + ASSERT(ftype < XFS_DIR3_FT_MAX); + } + +-static __uint8_t ++static uint8_t + xfs_dir3_data_get_ftype( + struct xfs_dir2_data_entry *dep) + { +- __uint8_t ftype = dep->name[dep->namelen]; ++ uint8_t ftype = dep->name[dep->namelen]; + + if (ftype >= XFS_DIR3_FT_MAX) + return XFS_DIR3_FT_UNKNOWN; +@@ -271,7 +271,7 @@ xfs_dir3_data_get_ftype( + static void + xfs_dir3_data_put_ftype( + struct xfs_dir2_data_entry *dep, +- __uint8_t type) ++ uint8_t type) + { + ASSERT(type < XFS_DIR3_FT_MAX); + ASSERT(dep->namelen != 0); +diff --git a/libxfs/xfs_da_format.h b/libxfs/xfs_da_format.h +index 9a492a9..38cba81 100644 +--- a/libxfs/xfs_da_format.h ++++ b/libxfs/xfs_da_format.h +@@ -111,11 +111,11 @@ struct xfs_da3_intnode { + * appropriate. + */ + struct xfs_da3_icnode_hdr { +- __uint32_t forw; +- __uint32_t back; +- __uint16_t magic; +- __uint16_t count; +- __uint16_t level; ++ uint32_t forw; ++ uint32_t back; ++ uint16_t magic; ++ uint16_t count; ++ uint16_t level; + }; + + /* +@@ -187,14 +187,14 @@ struct xfs_da3_icnode_hdr { + /* + * Byte offset in data block and shortform entry. + */ +-typedef __uint16_t xfs_dir2_data_off_t; ++typedef uint16_t xfs_dir2_data_off_t; + #define NULLDATAOFF 0xffffU + typedef uint xfs_dir2_data_aoff_t; /* argument form */ + + /* + * Offset in data space of a data entry. + */ +-typedef __uint32_t xfs_dir2_dataptr_t; ++typedef uint32_t xfs_dir2_dataptr_t; + #define XFS_DIR2_MAX_DATAPTR ((xfs_dir2_dataptr_t)0xffffffff) + #define XFS_DIR2_NULL_DATAPTR ((xfs_dir2_dataptr_t)0) + +@@ -206,7 +206,7 @@ typedef xfs_off_t xfs_dir2_off_t; + /* + * Directory block number (logical dirblk in file) + */ +-typedef __uint32_t xfs_dir2_db_t; ++typedef uint32_t xfs_dir2_db_t; + + #define XFS_INO32_SIZE 4 + #define XFS_INO64_SIZE 8 +@@ -226,9 +226,9 @@ typedef __uint32_t xfs_dir2_db_t; + * over them. + */ + typedef struct xfs_dir2_sf_hdr { +- __uint8_t count; /* count of entries */ +- __uint8_t i8count; /* count of 8-byte inode #s */ +- __uint8_t parent[8]; /* parent dir inode number */ ++ uint8_t count; /* count of entries */ ++ uint8_t i8count; /* count of 8-byte inode #s */ ++ uint8_t parent[8]; /* parent dir inode number */ + } __packed xfs_dir2_sf_hdr_t; + + typedef struct xfs_dir2_sf_entry { +@@ -447,11 +447,11 @@ struct xfs_dir3_leaf_hdr { + }; + + struct xfs_dir3_icleaf_hdr { +- __uint32_t forw; +- __uint32_t back; +- __uint16_t magic; +- __uint16_t count; +- __uint16_t stale; ++ uint32_t forw; ++ uint32_t back; ++ uint16_t magic; ++ uint16_t count; ++ uint16_t stale; + }; + + /* +@@ -538,10 +538,10 @@ struct xfs_dir3_free { + * xfs_dir3_free_hdr_from_disk/xfs_dir3_free_hdr_to_disk. + */ + struct xfs_dir3_icfree_hdr { +- __uint32_t magic; +- __uint32_t firstdb; +- __uint32_t nvalid; +- __uint32_t nused; ++ uint32_t magic; ++ uint32_t firstdb; ++ uint32_t nvalid; ++ uint32_t nused; + + }; + +@@ -632,10 +632,10 @@ typedef struct xfs_attr_shortform { + __u8 padding; + } hdr; + struct xfs_attr_sf_entry { +- __uint8_t namelen; /* actual length of name (no NULL) */ +- __uint8_t valuelen; /* actual length of value (no NULL) */ +- __uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */ +- __uint8_t nameval[1]; /* name & value bytes concatenated */ ++ uint8_t namelen; /* actual length of name (no NULL) */ ++ uint8_t valuelen; /* actual length of value (no NULL) */ ++ uint8_t flags; /* flags bits (see xfs_attr_leaf.h) */ ++ uint8_t nameval[1]; /* name & value bytes concatenated */ + } list[1]; /* variable sized array */ + } xfs_attr_shortform_t; + +@@ -725,22 +725,22 @@ struct xfs_attr3_leafblock { + * incore, neutral version of the attribute leaf header + */ + struct xfs_attr3_icleaf_hdr { +- __uint32_t forw; +- __uint32_t back; +- __uint16_t magic; +- __uint16_t count; +- __uint16_t usedbytes; ++ uint32_t forw; ++ uint32_t back; ++ uint16_t magic; ++ uint16_t count; ++ uint16_t usedbytes; + /* + * firstused is 32-bit here instead of 16-bit like the on-disk variant + * to support maximum fsb size of 64k without overflow issues throughout + * the attr code. Instead, the overflow condition is handled on + * conversion to/from disk. + */ +- __uint32_t firstused; ++ uint32_t firstused; + __u8 holes; + struct { +- __uint16_t base; +- __uint16_t size; ++ uint16_t base; ++ uint16_t size; + } freemap[XFS_ATTR_LEAF_MAPSIZE]; + }; + +diff --git a/libxfs/xfs_dir2.h b/libxfs/xfs_dir2.h +index d6e6d9d..21c8f8b 100644 +--- a/libxfs/xfs_dir2.h ++++ b/libxfs/xfs_dir2.h +@@ -47,9 +47,9 @@ struct xfs_dir_ops { + struct xfs_dir2_sf_entry * + (*sf_nextentry)(struct xfs_dir2_sf_hdr *hdr, + struct xfs_dir2_sf_entry *sfep); +- __uint8_t (*sf_get_ftype)(struct xfs_dir2_sf_entry *sfep); ++ uint8_t (*sf_get_ftype)(struct xfs_dir2_sf_entry *sfep); + void (*sf_put_ftype)(struct xfs_dir2_sf_entry *sfep, +- __uint8_t ftype); ++ uint8_t ftype); + xfs_ino_t (*sf_get_ino)(struct xfs_dir2_sf_hdr *hdr, + struct xfs_dir2_sf_entry *sfep); + void (*sf_put_ino)(struct xfs_dir2_sf_hdr *hdr, +@@ -60,9 +60,9 @@ struct xfs_dir_ops { + xfs_ino_t ino); + + int (*data_entsize)(int len); +- __uint8_t (*data_get_ftype)(struct xfs_dir2_data_entry *dep); ++ uint8_t (*data_get_ftype)(struct xfs_dir2_data_entry *dep); + void (*data_put_ftype)(struct xfs_dir2_data_entry *dep, +- __uint8_t ftype); ++ uint8_t ftype); + __be16 * (*data_entry_tag_p)(struct xfs_dir2_data_entry *dep); + struct xfs_dir2_data_free * + (*data_bestfree_p)(struct xfs_dir2_data_hdr *hdr); +diff --git a/libxfs/xfs_dir2_leaf.c b/libxfs/xfs_dir2_leaf.c +index f80d91f..40a35b8 100644 +--- a/libxfs/xfs_dir2_leaf.c ++++ b/libxfs/xfs_dir2_leaf.c +@@ -142,7 +142,7 @@ xfs_dir3_leaf_check_int( + static bool + xfs_dir3_leaf_verify( + struct xfs_buf *bp, +- __uint16_t magic) ++ uint16_t magic) + { + struct xfs_mount *mp = bp->b_target->bt_mount; + struct xfs_dir2_leaf *leaf = bp->b_addr; +@@ -151,7 +151,7 @@ xfs_dir3_leaf_verify( + + if (xfs_sb_version_hascrc(&mp->m_sb)) { + struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr; +- __uint16_t magic3; ++ uint16_t magic3; + + magic3 = (magic == XFS_DIR2_LEAF1_MAGIC) ? XFS_DIR3_LEAF1_MAGIC + : XFS_DIR3_LEAFN_MAGIC; +@@ -175,7 +175,7 @@ xfs_dir3_leaf_verify( + static void + __read_verify( + struct xfs_buf *bp, +- __uint16_t magic) ++ uint16_t magic) + { + struct xfs_mount *mp = bp->b_target->bt_mount; + +@@ -192,7 +192,7 @@ __read_verify( + static void + __write_verify( + struct xfs_buf *bp, +- __uint16_t magic) ++ uint16_t magic) + { + struct xfs_mount *mp = bp->b_target->bt_mount; + struct xfs_buf_log_item *bip = bp->b_fspriv; +@@ -296,7 +296,7 @@ xfs_dir3_leaf_init( + struct xfs_trans *tp, + struct xfs_buf *bp, + xfs_ino_t owner, +- __uint16_t type) ++ uint16_t type) + { + struct xfs_dir2_leaf *leaf = bp->b_addr; + +@@ -340,7 +340,7 @@ xfs_dir3_leaf_get_buf( + xfs_da_args_t *args, + xfs_dir2_db_t bno, + struct xfs_buf **bpp, +- __uint16_t magic) ++ uint16_t magic) + { + struct xfs_inode *dp = args->dp; + struct xfs_trans *tp = args->trans; +diff --git a/libxfs/xfs_dir2_priv.h b/libxfs/xfs_dir2_priv.h +index 39f8604..011df4d 100644 +--- a/libxfs/xfs_dir2_priv.h ++++ b/libxfs/xfs_dir2_priv.h +@@ -69,7 +69,7 @@ extern void xfs_dir3_leaf_compact_x1(struct xfs_dir3_icleaf_hdr *leafhdr, + struct xfs_dir2_leaf_entry *ents, int *indexp, + int *lowstalep, int *highstalep, int *lowlogp, int *highlogp); + extern int xfs_dir3_leaf_get_buf(struct xfs_da_args *args, xfs_dir2_db_t bno, +- struct xfs_buf **bpp, __uint16_t magic); ++ struct xfs_buf **bpp, uint16_t magic); + extern void xfs_dir3_leaf_log_ents(struct xfs_da_args *args, + struct xfs_buf *bp, int first, int last); + extern void xfs_dir3_leaf_log_header(struct xfs_da_args *args, +diff --git a/libxfs/xfs_dir2_sf.c b/libxfs/xfs_dir2_sf.c +index 195f816..fdbe5e1 100644 +--- a/libxfs/xfs_dir2_sf.c ++++ b/libxfs/xfs_dir2_sf.c +@@ -645,7 +645,7 @@ xfs_dir2_sf_verify( + int offset; + int size; + int error; +- __uint8_t filetype; ++ uint8_t filetype; + + ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_LOCAL); + /* +diff --git a/libxfs/xfs_format.h b/libxfs/xfs_format.h +index 4c3ed1f..fe617d0 100644 +--- a/libxfs/xfs_format.h ++++ b/libxfs/xfs_format.h +@@ -103,8 +103,8 @@ struct xfs_ifork; + * Must be padded to 64 bit alignment. + */ + typedef struct xfs_sb { +- __uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */ +- __uint32_t sb_blocksize; /* logical block size, bytes */ ++ uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */ ++ uint32_t sb_blocksize; /* logical block size, bytes */ + xfs_rfsblock_t sb_dblocks; /* number of data blocks */ + xfs_rfsblock_t sb_rblocks; /* number of realtime blocks */ + xfs_rtblock_t sb_rextents; /* number of realtime extents */ +@@ -118,45 +118,45 @@ typedef struct xfs_sb { + xfs_agnumber_t sb_agcount; /* number of allocation groups */ + xfs_extlen_t sb_rbmblocks; /* number of rt bitmap blocks */ + xfs_extlen_t sb_logblocks; /* number of log blocks */ +- __uint16_t sb_versionnum; /* header version == XFS_SB_VERSION */ +- __uint16_t sb_sectsize; /* volume sector size, bytes */ +- __uint16_t sb_inodesize; /* inode size, bytes */ +- __uint16_t sb_inopblock; /* inodes per block */ ++ uint16_t sb_versionnum; /* header version == XFS_SB_VERSION */ ++ uint16_t sb_sectsize; /* volume sector size, bytes */ ++ uint16_t sb_inodesize; /* inode size, bytes */ ++ uint16_t sb_inopblock; /* inodes per block */ + char sb_fname[12]; /* file system name */ +- __uint8_t sb_blocklog; /* log2 of sb_blocksize */ +- __uint8_t sb_sectlog; /* log2 of sb_sectsize */ +- __uint8_t sb_inodelog; /* log2 of sb_inodesize */ +- __uint8_t sb_inopblog; /* log2 of sb_inopblock */ +- __uint8_t sb_agblklog; /* log2 of sb_agblocks (rounded up) */ +- __uint8_t sb_rextslog; /* log2 of sb_rextents */ +- __uint8_t sb_inprogress; /* mkfs is in progress, don't mount */ +- __uint8_t sb_imax_pct; /* max % of fs for inode space */ ++ uint8_t sb_blocklog; /* log2 of sb_blocksize */ ++ uint8_t sb_sectlog; /* log2 of sb_sectsize */ ++ uint8_t sb_inodelog; /* log2 of sb_inodesize */ ++ uint8_t sb_inopblog; /* log2 of sb_inopblock */ ++ uint8_t sb_agblklog; /* log2 of sb_agblocks (rounded up) */ ++ uint8_t sb_rextslog; /* log2 of sb_rextents */ ++ uint8_t sb_inprogress; /* mkfs is in progress, don't mount */ ++ uint8_t sb_imax_pct; /* max % of fs for inode space */ + /* statistics */ + /* + * These fields must remain contiguous. If you really + * want to change their layout, make sure you fix the + * code in xfs_trans_apply_sb_deltas(). + */ +- __uint64_t sb_icount; /* allocated inodes */ +- __uint64_t sb_ifree; /* free inodes */ +- __uint64_t sb_fdblocks; /* free data blocks */ +- __uint64_t sb_frextents; /* free realtime extents */ ++ uint64_t sb_icount; /* allocated inodes */ ++ uint64_t sb_ifree; /* free inodes */ ++ uint64_t sb_fdblocks; /* free data blocks */ ++ uint64_t sb_frextents; /* free realtime extents */ + /* + * End contiguous fields. + */ + xfs_ino_t sb_uquotino; /* user quota inode */ + xfs_ino_t sb_gquotino; /* group quota inode */ +- __uint16_t sb_qflags; /* quota flags */ +- __uint8_t sb_flags; /* misc. flags */ +- __uint8_t sb_shared_vn; /* shared version number */ ++ uint16_t sb_qflags; /* quota flags */ ++ uint8_t sb_flags; /* misc. flags */ ++ uint8_t sb_shared_vn; /* shared version number */ + xfs_extlen_t sb_inoalignmt; /* inode chunk alignment, fsblocks */ +- __uint32_t sb_unit; /* stripe or raid unit */ +- __uint32_t sb_width; /* stripe or raid width */ +- __uint8_t sb_dirblklog; /* log2 of dir block size (fsbs) */ +- __uint8_t sb_logsectlog; /* log2 of the log sector size */ +- __uint16_t sb_logsectsize; /* sector size for the log, bytes */ +- __uint32_t sb_logsunit; /* stripe unit size for the log */ +- __uint32_t sb_features2; /* additional feature bits */ ++ uint32_t sb_unit; /* stripe or raid unit */ ++ uint32_t sb_width; /* stripe or raid width */ ++ uint8_t sb_dirblklog; /* log2 of dir block size (fsbs) */ ++ uint8_t sb_logsectlog; /* log2 of the log sector size */ ++ uint16_t sb_logsectsize; /* sector size for the log, bytes */ ++ uint32_t sb_logsunit; /* stripe unit size for the log */ ++ uint32_t sb_features2; /* additional feature bits */ + + /* + * bad features2 field as a result of failing to pad the sb structure to +@@ -167,17 +167,17 @@ typedef struct xfs_sb { + * the value in sb_features2 when formatting the incore superblock to + * the disk buffer. + */ +- __uint32_t sb_bad_features2; ++ uint32_t sb_bad_features2; + + /* version 5 superblock fields start here */ + + /* feature masks */ +- __uint32_t sb_features_compat; +- __uint32_t sb_features_ro_compat; +- __uint32_t sb_features_incompat; +- __uint32_t sb_features_log_incompat; ++ uint32_t sb_features_compat; ++ uint32_t sb_features_ro_compat; ++ uint32_t sb_features_incompat; ++ uint32_t sb_features_log_incompat; + +- __uint32_t sb_crc; /* superblock crc */ ++ uint32_t sb_crc; /* superblock crc */ + xfs_extlen_t sb_spino_align; /* sparse inode chunk alignment */ + + xfs_ino_t sb_pquotino; /* project quota inode */ +@@ -449,7 +449,7 @@ static inline void xfs_sb_version_addprojid32bit(struct xfs_sb *sbp) + static inline bool + xfs_sb_has_compat_feature( + struct xfs_sb *sbp, +- __uint32_t feature) ++ uint32_t feature) + { + return (sbp->sb_features_compat & feature) != 0; + } +@@ -465,7 +465,7 @@ xfs_sb_has_compat_feature( + static inline bool + xfs_sb_has_ro_compat_feature( + struct xfs_sb *sbp, +- __uint32_t feature) ++ uint32_t feature) + { + return (sbp->sb_features_ro_compat & feature) != 0; + } +@@ -482,7 +482,7 @@ xfs_sb_has_ro_compat_feature( + static inline bool + xfs_sb_has_incompat_feature( + struct xfs_sb *sbp, +- __uint32_t feature) ++ uint32_t feature) + { + return (sbp->sb_features_incompat & feature) != 0; + } +@@ -492,7 +492,7 @@ xfs_sb_has_incompat_feature( + static inline bool + xfs_sb_has_incompat_log_feature( + struct xfs_sb *sbp, +- __uint32_t feature) ++ uint32_t feature) + { + return (sbp->sb_features_log_incompat & feature) != 0; + } +@@ -594,8 +594,8 @@ xfs_is_quota_inode(struct xfs_sb *sbp, xfs_ino_t ino) + */ + #define XFS_FSB_TO_B(mp,fsbno) ((xfs_fsize_t)(fsbno) << (mp)->m_sb.sb_blocklog) + #define XFS_B_TO_FSB(mp,b) \ +- ((((__uint64_t)(b)) + (mp)->m_blockmask) >> (mp)->m_sb.sb_blocklog) +-#define XFS_B_TO_FSBT(mp,b) (((__uint64_t)(b)) >> (mp)->m_sb.sb_blocklog) ++ ((((uint64_t)(b)) + (mp)->m_blockmask) >> (mp)->m_sb.sb_blocklog) ++#define XFS_B_TO_FSBT(mp,b) (((uint64_t)(b)) >> (mp)->m_sb.sb_blocklog) + #define XFS_B_FSB_OFFSET(mp,b) ((b) & (mp)->m_blockmask) + + /* +@@ -1072,7 +1072,7 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev) + * next agno_log bits - ag number + * high agno_log-agblklog-inopblog bits - 0 + */ +-#define XFS_INO_MASK(k) (__uint32_t)((1ULL << (k)) - 1) ++#define XFS_INO_MASK(k) (uint32_t)((1ULL << (k)) - 1) + #define XFS_INO_OFFSET_BITS(mp) (mp)->m_sb.sb_inopblog + #define XFS_INO_AGBNO_BITS(mp) (mp)->m_sb.sb_agblklog + #define XFS_INO_AGINO_BITS(mp) (mp)->m_agino_log +@@ -1269,16 +1269,16 @@ typedef __be32 xfs_alloc_ptr_t; + #define XFS_FIBT_MAGIC 0x46494254 /* 'FIBT' */ + #define XFS_FIBT_CRC_MAGIC 0x46494233 /* 'FIB3' */ + +-typedef __uint64_t xfs_inofree_t; ++typedef uint64_t xfs_inofree_t; + #define XFS_INODES_PER_CHUNK (NBBY * sizeof(xfs_inofree_t)) + #define XFS_INODES_PER_CHUNK_LOG (XFS_NBBYLOG + 3) + #define XFS_INOBT_ALL_FREE ((xfs_inofree_t)-1) + #define XFS_INOBT_MASK(i) ((xfs_inofree_t)1 << (i)) + + #define XFS_INOBT_HOLEMASK_FULL 0 /* holemask for full chunk */ +-#define XFS_INOBT_HOLEMASK_BITS (NBBY * sizeof(__uint16_t)) ++#define XFS_INOBT_HOLEMASK_BITS (NBBY * sizeof(uint16_t)) + #define XFS_INODES_PER_HOLEMASK_BIT \ +- (XFS_INODES_PER_CHUNK / (NBBY * sizeof(__uint16_t))) ++ (XFS_INODES_PER_CHUNK / (NBBY * sizeof(uint16_t))) + + static inline xfs_inofree_t xfs_inobt_maskn(int i, int n) + { +@@ -1312,9 +1312,9 @@ typedef struct xfs_inobt_rec { + + typedef struct xfs_inobt_rec_incore { + xfs_agino_t ir_startino; /* starting inode number */ +- __uint16_t ir_holemask; /* hole mask for sparse chunks */ +- __uint8_t ir_count; /* total inode count */ +- __uint8_t ir_freecount; /* count of free inodes (set bits) */ ++ uint16_t ir_holemask; /* hole mask for sparse chunks */ ++ uint8_t ir_count; /* total inode count */ ++ uint8_t ir_freecount; /* count of free inodes (set bits) */ + xfs_inofree_t ir_free; /* free inode mask */ + } xfs_inobt_rec_incore_t; + +@@ -1397,15 +1397,15 @@ struct xfs_rmap_rec { + * rm_offset:54-60 aren't used and should be zero + * rm_offset:0-53 is the block offset within the inode + */ +-#define XFS_RMAP_OFF_ATTR_FORK ((__uint64_t)1ULL << 63) +-#define XFS_RMAP_OFF_BMBT_BLOCK ((__uint64_t)1ULL << 62) +-#define XFS_RMAP_OFF_UNWRITTEN ((__uint64_t)1ULL << 61) ++#define XFS_RMAP_OFF_ATTR_FORK ((uint64_t)1ULL << 63) ++#define XFS_RMAP_OFF_BMBT_BLOCK ((uint64_t)1ULL << 62) ++#define XFS_RMAP_OFF_UNWRITTEN ((uint64_t)1ULL << 61) + +-#define XFS_RMAP_LEN_MAX ((__uint32_t)~0U) ++#define XFS_RMAP_LEN_MAX ((uint32_t)~0U) + #define XFS_RMAP_OFF_FLAGS (XFS_RMAP_OFF_ATTR_FORK | \ + XFS_RMAP_OFF_BMBT_BLOCK | \ + XFS_RMAP_OFF_UNWRITTEN) +-#define XFS_RMAP_OFF_MASK ((__uint64_t)0x3FFFFFFFFFFFFFULL) ++#define XFS_RMAP_OFF_MASK ((uint64_t)0x3FFFFFFFFFFFFFULL) + + #define XFS_RMAP_OFF(off) ((off) & XFS_RMAP_OFF_MASK) + +@@ -1431,8 +1431,8 @@ struct xfs_rmap_rec { + struct xfs_rmap_irec { + xfs_agblock_t rm_startblock; /* extent start block */ + xfs_extlen_t rm_blockcount; /* extent length */ +- __uint64_t rm_owner; /* extent owner */ +- __uint64_t rm_offset; /* offset within the owner */ ++ uint64_t rm_owner; /* extent owner */ ++ uint64_t rm_offset; /* offset within the owner */ + unsigned int rm_flags; /* state flags */ + }; + +@@ -1544,11 +1544,11 @@ typedef struct xfs_bmbt_rec { + __be64 l0, l1; + } xfs_bmbt_rec_t; + +-typedef __uint64_t xfs_bmbt_rec_base_t; /* use this for casts */ ++typedef uint64_t xfs_bmbt_rec_base_t; /* use this for casts */ + typedef xfs_bmbt_rec_t xfs_bmdr_rec_t; + + typedef struct xfs_bmbt_rec_host { +- __uint64_t l0, l1; ++ uint64_t l0, l1; + } xfs_bmbt_rec_host_t; + + /* +diff --git a/libxfs/xfs_fs.h b/libxfs/xfs_fs.h +index 1831cff..3384152 100644 +--- a/libxfs/xfs_fs.h ++++ b/libxfs/xfs_fs.h +@@ -323,10 +323,10 @@ typedef struct xfs_bstat { + * and using two 16bit values to hold new 32bit projid was choosen + * to retain compatibility with "old" filesystems). + */ +-static inline __uint32_t ++static inline uint32_t + bstat_get_projid(struct xfs_bstat *bs) + { +- return (__uint32_t)bs->bs_projid_hi << 16 | bs->bs_projid_lo; ++ return (uint32_t)bs->bs_projid_hi << 16 | bs->bs_projid_lo; + } + + /* +@@ -476,10 +476,10 @@ typedef struct xfs_handle { + */ + typedef struct xfs_swapext + { +- __int64_t sx_version; /* version */ ++ int64_t sx_version; /* version */ + #define XFS_SX_VERSION 0 +- __int64_t sx_fdtarget; /* fd of target file */ +- __int64_t sx_fdtmp; /* fd of tmp file */ ++ int64_t sx_fdtarget; /* fd of target file */ ++ int64_t sx_fdtmp; /* fd of tmp file */ + xfs_off_t sx_offset; /* offset into file */ + xfs_off_t sx_length; /* leng from offset */ + char sx_pad[16]; /* pad space, unused */ +@@ -566,7 +566,7 @@ typedef struct xfs_swapext + #define XFS_IOC_ATTRLIST_BY_HANDLE _IOW ('X', 122, struct xfs_fsop_attrlist_handlereq) + #define XFS_IOC_ATTRMULTI_BY_HANDLE _IOW ('X', 123, struct xfs_fsop_attrmulti_handlereq) + #define XFS_IOC_FSGEOMETRY _IOR ('X', 124, struct xfs_fsop_geom) +-#define XFS_IOC_GOINGDOWN _IOR ('X', 125, __uint32_t) ++#define XFS_IOC_GOINGDOWN _IOR ('X', 125, uint32_t) + /* XFS_IOC_GETFSUUID ---------- deprecated 140 */ + + /* reflink ioctls; these MUST match the btrfs ioctl definitions */ +diff --git a/libxfs/xfs_ialloc.c b/libxfs/xfs_ialloc.c +index 55cc450..8d24518 100644 +--- a/libxfs/xfs_ialloc.c ++++ b/libxfs/xfs_ialloc.c +@@ -134,9 +134,9 @@ xfs_inobt_get_rec( + STATIC int + xfs_inobt_insert_rec( + struct xfs_btree_cur *cur, +- __uint16_t holemask, +- __uint8_t count, +- __int32_t freecount, ++ uint16_t holemask, ++ uint8_t count, ++ int32_t freecount, + xfs_inofree_t free, + int *stat) + { +diff --git a/libxfs/xfs_ialloc_btree.c b/libxfs/xfs_ialloc_btree.c +index 7b4be76..5b28105 100644 +--- a/libxfs/xfs_ialloc_btree.c ++++ b/libxfs/xfs_ialloc_btree.c +@@ -218,12 +218,12 @@ xfs_finobt_init_ptr_from_cur( + ptr->s = agi->agi_free_root; + } + +-STATIC __int64_t ++STATIC int64_t + xfs_inobt_key_diff( + struct xfs_btree_cur *cur, + union xfs_btree_key *key) + { +- return (__int64_t)be32_to_cpu(key->inobt.ir_startino) - ++ return (int64_t)be32_to_cpu(key->inobt.ir_startino) - + cur->bc_rec.i.ir_startino; + } + +diff --git a/libxfs/xfs_inode_buf.c b/libxfs/xfs_inode_buf.c +index 2972701..fcc6fb8 100644 +--- a/libxfs/xfs_inode_buf.c ++++ b/libxfs/xfs_inode_buf.c +@@ -442,7 +442,7 @@ xfs_dinode_calc_crc( + struct xfs_mount *mp, + struct xfs_dinode *dip) + { +- __uint32_t crc; ++ uint32_t crc; + + if (dip->di_version < 3) + return; +diff --git a/libxfs/xfs_inode_buf.h b/libxfs/xfs_inode_buf.h +index 6848a0a..0827d7d 100644 +--- a/libxfs/xfs_inode_buf.h ++++ b/libxfs/xfs_inode_buf.h +@@ -28,26 +28,26 @@ struct xfs_dinode; + * format specific structures at the appropriate time. + */ + struct xfs_icdinode { +- __int8_t di_version; /* inode version */ +- __int8_t di_format; /* format of di_c data */ +- __uint16_t di_flushiter; /* incremented on flush */ +- __uint32_t di_uid; /* owner's user id */ +- __uint32_t di_gid; /* owner's group id */ +- __uint16_t di_projid_lo; /* lower part of owner's project id */ +- __uint16_t di_projid_hi; /* higher part of owner's project id */ ++ int8_t di_version; /* inode version */ ++ int8_t di_format; /* format of di_c data */ ++ uint16_t di_flushiter; /* incremented on flush */ ++ uint32_t di_uid; /* owner's user id */ ++ uint32_t di_gid; /* owner's group id */ ++ uint16_t di_projid_lo; /* lower part of owner's project id */ ++ uint16_t di_projid_hi; /* higher part of owner's project id */ + xfs_fsize_t di_size; /* number of bytes in file */ + xfs_rfsblock_t di_nblocks; /* # of direct & btree blocks used */ + xfs_extlen_t di_extsize; /* basic/minimum extent size for file */ + xfs_extnum_t di_nextents; /* number of extents in data fork */ + xfs_aextnum_t di_anextents; /* number of extents in attribute fork*/ +- __uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */ +- __int8_t di_aformat; /* format of attr fork's data */ +- __uint32_t di_dmevmask; /* DMIG event mask */ +- __uint16_t di_dmstate; /* DMIG state info */ +- __uint16_t di_flags; /* random flags, XFS_DIFLAG_... */ ++ uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */ ++ int8_t di_aformat; /* format of attr fork's data */ ++ uint32_t di_dmevmask; /* DMIG event mask */ ++ uint16_t di_dmstate; /* DMIG state info */ ++ uint16_t di_flags; /* random flags, XFS_DIFLAG_... */ + +- __uint64_t di_flags2; /* more random flags */ +- __uint32_t di_cowextsize; /* basic cow extent size for file */ ++ uint64_t di_flags2; /* more random flags */ ++ uint32_t di_cowextsize; /* basic cow extent size for file */ + + xfs_ictimestamp_t di_crtime; /* time created */ + }; +diff --git a/libxfs/xfs_log_format.h b/libxfs/xfs_log_format.h +index 7ae571f..b6291d1 100644 +--- a/libxfs/xfs_log_format.h ++++ b/libxfs/xfs_log_format.h +@@ -31,7 +31,7 @@ struct xfs_trans_res; + * through all the log items definitions and everything they encode into the + * log. + */ +-typedef __uint32_t xlog_tid_t; ++typedef uint32_t xlog_tid_t; + + #define XLOG_MIN_ICLOGS 2 + #define XLOG_MAX_ICLOGS 8 +@@ -211,7 +211,7 @@ typedef struct xfs_log_iovec { + typedef struct xfs_trans_header { + uint th_magic; /* magic number */ + uint th_type; /* transaction type */ +- __int32_t th_tid; /* transaction id (unused) */ ++ int32_t th_tid; /* transaction id (unused) */ + uint th_num_items; /* num items logged by trans */ + } xfs_trans_header_t; + +@@ -265,52 +265,52 @@ typedef struct xfs_trans_header { + * must be added on to the end. + */ + typedef struct xfs_inode_log_format { +- __uint16_t ilf_type; /* inode log item type */ +- __uint16_t ilf_size; /* size of this item */ +- __uint32_t ilf_fields; /* flags for fields logged */ +- __uint16_t ilf_asize; /* size of attr d/ext/root */ +- __uint16_t ilf_dsize; /* size of data/ext/root */ +- __uint64_t ilf_ino; /* inode number */ ++ uint16_t ilf_type; /* inode log item type */ ++ uint16_t ilf_size; /* size of this item */ ++ uint32_t ilf_fields; /* flags for fields logged */ ++ uint16_t ilf_asize; /* size of attr d/ext/root */ ++ uint16_t ilf_dsize; /* size of data/ext/root */ ++ uint64_t ilf_ino; /* inode number */ + union { +- __uint32_t ilfu_rdev; /* rdev value for dev inode*/ ++ uint32_t ilfu_rdev; /* rdev value for dev inode*/ + uuid_t ilfu_uuid; /* mount point value */ + } ilf_u; +- __int64_t ilf_blkno; /* blkno of inode buffer */ +- __int32_t ilf_len; /* len of inode buffer */ +- __int32_t ilf_boffset; /* off of inode in buffer */ ++ int64_t ilf_blkno; /* blkno of inode buffer */ ++ int32_t ilf_len; /* len of inode buffer */ ++ int32_t ilf_boffset; /* off of inode in buffer */ + } xfs_inode_log_format_t; + + typedef struct xfs_inode_log_format_32 { +- __uint16_t ilf_type; /* inode log item type */ +- __uint16_t ilf_size; /* size of this item */ +- __uint32_t ilf_fields; /* flags for fields logged */ +- __uint16_t ilf_asize; /* size of attr d/ext/root */ +- __uint16_t ilf_dsize; /* size of data/ext/root */ +- __uint64_t ilf_ino; /* inode number */ ++ uint16_t ilf_type; /* inode log item type */ ++ uint16_t ilf_size; /* size of this item */ ++ uint32_t ilf_fields; /* flags for fields logged */ ++ uint16_t ilf_asize; /* size of attr d/ext/root */ ++ uint16_t ilf_dsize; /* size of data/ext/root */ ++ uint64_t ilf_ino; /* inode number */ + union { +- __uint32_t ilfu_rdev; /* rdev value for dev inode*/ ++ uint32_t ilfu_rdev; /* rdev value for dev inode*/ + uuid_t ilfu_uuid; /* mount point value */ + } ilf_u; +- __int64_t ilf_blkno; /* blkno of inode buffer */ +- __int32_t ilf_len; /* len of inode buffer */ +- __int32_t ilf_boffset; /* off of inode in buffer */ ++ int64_t ilf_blkno; /* blkno of inode buffer */ ++ int32_t ilf_len; /* len of inode buffer */ ++ int32_t ilf_boffset; /* off of inode in buffer */ + } __attribute__((packed)) xfs_inode_log_format_32_t; + + typedef struct xfs_inode_log_format_64 { +- __uint16_t ilf_type; /* inode log item type */ +- __uint16_t ilf_size; /* size of this item */ +- __uint32_t ilf_fields; /* flags for fields logged */ +- __uint16_t ilf_asize; /* size of attr d/ext/root */ +- __uint16_t ilf_dsize; /* size of data/ext/root */ +- __uint32_t ilf_pad; /* pad for 64 bit boundary */ +- __uint64_t ilf_ino; /* inode number */ ++ uint16_t ilf_type; /* inode log item type */ ++ uint16_t ilf_size; /* size of this item */ ++ uint32_t ilf_fields; /* flags for fields logged */ ++ uint16_t ilf_asize; /* size of attr d/ext/root */ ++ uint16_t ilf_dsize; /* size of data/ext/root */ ++ uint32_t ilf_pad; /* pad for 64 bit boundary */ ++ uint64_t ilf_ino; /* inode number */ + union { +- __uint32_t ilfu_rdev; /* rdev value for dev inode*/ ++ uint32_t ilfu_rdev; /* rdev value for dev inode*/ + uuid_t ilfu_uuid; /* mount point value */ + } ilf_u; +- __int64_t ilf_blkno; /* blkno of inode buffer */ +- __int32_t ilf_len; /* len of inode buffer */ +- __int32_t ilf_boffset; /* off of inode in buffer */ ++ int64_t ilf_blkno; /* blkno of inode buffer */ ++ int32_t ilf_len; /* len of inode buffer */ ++ int32_t ilf_boffset; /* off of inode in buffer */ + } xfs_inode_log_format_64_t; + + +@@ -379,8 +379,8 @@ static inline int xfs_ilog_fdata(int w) + * information. + */ + typedef struct xfs_ictimestamp { +- __int32_t t_sec; /* timestamp seconds */ +- __int32_t t_nsec; /* timestamp nanoseconds */ ++ int32_t t_sec; /* timestamp seconds */ ++ int32_t t_nsec; /* timestamp nanoseconds */ + } xfs_ictimestamp_t; + + /* +@@ -388,18 +388,18 @@ typedef struct xfs_ictimestamp { + * kept identical to struct xfs_dinode except for the endianness annotations. + */ + struct xfs_log_dinode { +- __uint16_t di_magic; /* inode magic # = XFS_DINODE_MAGIC */ +- __uint16_t di_mode; /* mode and type of file */ +- __int8_t di_version; /* inode version */ +- __int8_t di_format; /* format of di_c data */ +- __uint8_t di_pad3[2]; /* unused in v2/3 inodes */ +- __uint32_t di_uid; /* owner's user id */ +- __uint32_t di_gid; /* owner's group id */ +- __uint32_t di_nlink; /* number of links to file */ +- __uint16_t di_projid_lo; /* lower part of owner's project id */ +- __uint16_t di_projid_hi; /* higher part of owner's project id */ +- __uint8_t di_pad[6]; /* unused, zeroed space */ +- __uint16_t di_flushiter; /* incremented on flush */ ++ uint16_t di_magic; /* inode magic # = XFS_DINODE_MAGIC */ ++ uint16_t di_mode; /* mode and type of file */ ++ int8_t di_version; /* inode version */ ++ int8_t di_format; /* format of di_c data */ ++ uint8_t di_pad3[2]; /* unused in v2/3 inodes */ ++ uint32_t di_uid; /* owner's user id */ ++ uint32_t di_gid; /* owner's group id */ ++ uint32_t di_nlink; /* number of links to file */ ++ uint16_t di_projid_lo; /* lower part of owner's project id */ ++ uint16_t di_projid_hi; /* higher part of owner's project id */ ++ uint8_t di_pad[6]; /* unused, zeroed space */ ++ uint16_t di_flushiter; /* incremented on flush */ + xfs_ictimestamp_t di_atime; /* time last accessed */ + xfs_ictimestamp_t di_mtime; /* time last modified */ + xfs_ictimestamp_t di_ctime; /* time created/inode modified */ +@@ -408,23 +408,23 @@ struct xfs_log_dinode { + xfs_extlen_t di_extsize; /* basic/minimum extent size for file */ + xfs_extnum_t di_nextents; /* number of extents in data fork */ + xfs_aextnum_t di_anextents; /* number of extents in attribute fork*/ +- __uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */ +- __int8_t di_aformat; /* format of attr fork's data */ +- __uint32_t di_dmevmask; /* DMIG event mask */ +- __uint16_t di_dmstate; /* DMIG state info */ +- __uint16_t di_flags; /* random flags, XFS_DIFLAG_... */ +- __uint32_t di_gen; /* generation number */ ++ uint8_t di_forkoff; /* attr fork offs, <<3 for 64b align */ ++ int8_t di_aformat; /* format of attr fork's data */ ++ uint32_t di_dmevmask; /* DMIG event mask */ ++ uint16_t di_dmstate; /* DMIG state info */ ++ uint16_t di_flags; /* random flags, XFS_DIFLAG_... */ ++ uint32_t di_gen; /* generation number */ + + /* di_next_unlinked is the only non-core field in the old dinode */ + xfs_agino_t di_next_unlinked;/* agi unlinked list ptr */ + + /* start of the extended dinode, writable fields */ +- __uint32_t di_crc; /* CRC of the inode */ +- __uint64_t di_changecount; /* number of attribute changes */ ++ uint32_t di_crc; /* CRC of the inode */ ++ uint64_t di_changecount; /* number of attribute changes */ + xfs_lsn_t di_lsn; /* flush sequence */ +- __uint64_t di_flags2; /* more random flags */ +- __uint32_t di_cowextsize; /* basic cow extent size for file */ +- __uint8_t di_pad2[12]; /* more padding for future expansion */ ++ uint64_t di_flags2; /* more random flags */ ++ uint32_t di_cowextsize; /* basic cow extent size for file */ ++ uint8_t di_pad2[12]; /* more padding for future expansion */ + + /* fields only written to during inode creation */ + xfs_ictimestamp_t di_crtime; /* time created */ +@@ -483,7 +483,7 @@ typedef struct xfs_buf_log_format { + unsigned short blf_size; /* size of this item */ + unsigned short blf_flags; /* misc state */ + unsigned short blf_len; /* number of blocks in this buf */ +- __int64_t blf_blkno; /* starting blkno of this buf */ ++ int64_t blf_blkno; /* starting blkno of this buf */ + unsigned int blf_map_size; /* used size of data bitmap in words */ + unsigned int blf_data_map[XFS_BLF_DATAMAP_SIZE]; /* dirty bitmap */ + } xfs_buf_log_format_t; +@@ -533,7 +533,7 @@ xfs_blft_to_flags(struct xfs_buf_log_format *blf, enum xfs_blft type) + blf->blf_flags |= ((type << XFS_BLFT_SHIFT) & XFS_BLFT_MASK); + } + +-static inline __uint16_t ++static inline uint16_t + xfs_blft_from_flags(struct xfs_buf_log_format *blf) + { + return (blf->blf_flags & XFS_BLFT_MASK) >> XFS_BLFT_SHIFT; +@@ -554,14 +554,14 @@ typedef struct xfs_extent { + * conversion routine. + */ + typedef struct xfs_extent_32 { +- __uint64_t ext_start; +- __uint32_t ext_len; ++ uint64_t ext_start; ++ uint32_t ext_len; + } __attribute__((packed)) xfs_extent_32_t; + + typedef struct xfs_extent_64 { +- __uint64_t ext_start; +- __uint32_t ext_len; +- __uint32_t ext_pad; ++ uint64_t ext_start; ++ uint32_t ext_len; ++ uint32_t ext_pad; + } xfs_extent_64_t; + + /* +@@ -570,26 +570,26 @@ typedef struct xfs_extent_64 { + * size is given by efi_nextents. + */ + typedef struct xfs_efi_log_format { +- __uint16_t efi_type; /* efi log item type */ +- __uint16_t efi_size; /* size of this item */ +- __uint32_t efi_nextents; /* # extents to free */ +- __uint64_t efi_id; /* efi identifier */ ++ uint16_t efi_type; /* efi log item type */ ++ uint16_t efi_size; /* size of this item */ ++ uint32_t efi_nextents; /* # extents to free */ ++ uint64_t efi_id; /* efi identifier */ + xfs_extent_t efi_extents[1]; /* array of extents to free */ + } xfs_efi_log_format_t; + + typedef struct xfs_efi_log_format_32 { +- __uint16_t efi_type; /* efi log item type */ +- __uint16_t efi_size; /* size of this item */ +- __uint32_t efi_nextents; /* # extents to free */ +- __uint64_t efi_id; /* efi identifier */ ++ uint16_t efi_type; /* efi log item type */ ++ uint16_t efi_size; /* size of this item */ ++ uint32_t efi_nextents; /* # extents to free */ ++ uint64_t efi_id; /* efi identifier */ + xfs_extent_32_t efi_extents[1]; /* array of extents to free */ + } __attribute__((packed)) xfs_efi_log_format_32_t; + + typedef struct xfs_efi_log_format_64 { +- __uint16_t efi_type; /* efi log item type */ +- __uint16_t efi_size; /* size of this item */ +- __uint32_t efi_nextents; /* # extents to free */ +- __uint64_t efi_id; /* efi identifier */ ++ uint16_t efi_type; /* efi log item type */ ++ uint16_t efi_size; /* size of this item */ ++ uint32_t efi_nextents; /* # extents to free */ ++ uint64_t efi_id; /* efi identifier */ + xfs_extent_64_t efi_extents[1]; /* array of extents to free */ + } xfs_efi_log_format_64_t; + +@@ -599,26 +599,26 @@ typedef struct xfs_efi_log_format_64 { + * size is given by efd_nextents; + */ + typedef struct xfs_efd_log_format { +- __uint16_t efd_type; /* efd log item type */ +- __uint16_t efd_size; /* size of this item */ +- __uint32_t efd_nextents; /* # of extents freed */ +- __uint64_t efd_efi_id; /* id of corresponding efi */ ++ uint16_t efd_type; /* efd log item type */ ++ uint16_t efd_size; /* size of this item */ ++ uint32_t efd_nextents; /* # of extents freed */ ++ uint64_t efd_efi_id; /* id of corresponding efi */ + xfs_extent_t efd_extents[1]; /* array of extents freed */ + } xfs_efd_log_format_t; + + typedef struct xfs_efd_log_format_32 { +- __uint16_t efd_type; /* efd log item type */ +- __uint16_t efd_size; /* size of this item */ +- __uint32_t efd_nextents; /* # of extents freed */ +- __uint64_t efd_efi_id; /* id of corresponding efi */ ++ uint16_t efd_type; /* efd log item type */ ++ uint16_t efd_size; /* size of this item */ ++ uint32_t efd_nextents; /* # of extents freed */ ++ uint64_t efd_efi_id; /* id of corresponding efi */ + xfs_extent_32_t efd_extents[1]; /* array of extents freed */ + } __attribute__((packed)) xfs_efd_log_format_32_t; + + typedef struct xfs_efd_log_format_64 { +- __uint16_t efd_type; /* efd log item type */ +- __uint16_t efd_size; /* size of this item */ +- __uint32_t efd_nextents; /* # of extents freed */ +- __uint64_t efd_efi_id; /* id of corresponding efi */ ++ uint16_t efd_type; /* efd log item type */ ++ uint16_t efd_size; /* size of this item */ ++ uint32_t efd_nextents; /* # of extents freed */ ++ uint64_t efd_efi_id; /* id of corresponding efi */ + xfs_extent_64_t efd_extents[1]; /* array of extents freed */ + } xfs_efd_log_format_64_t; + +@@ -626,11 +626,11 @@ typedef struct xfs_efd_log_format_64 { + * RUI/RUD (reverse mapping) log format definitions + */ + struct xfs_map_extent { +- __uint64_t me_owner; +- __uint64_t me_startblock; +- __uint64_t me_startoff; +- __uint32_t me_len; +- __uint32_t me_flags; ++ uint64_t me_owner; ++ uint64_t me_startblock; ++ uint64_t me_startoff; ++ uint32_t me_len; ++ uint32_t me_flags; + }; + + /* rmap me_flags: upper bits are flags, lower byte is type code */ +@@ -659,10 +659,10 @@ struct xfs_map_extent { + * size is given by rui_nextents. + */ + struct xfs_rui_log_format { +- __uint16_t rui_type; /* rui log item type */ +- __uint16_t rui_size; /* size of this item */ +- __uint32_t rui_nextents; /* # extents to free */ +- __uint64_t rui_id; /* rui identifier */ ++ uint16_t rui_type; /* rui log item type */ ++ uint16_t rui_size; /* size of this item */ ++ uint32_t rui_nextents; /* # extents to free */ ++ uint64_t rui_id; /* rui identifier */ + struct xfs_map_extent rui_extents[]; /* array of extents to rmap */ + }; + +@@ -680,19 +680,19 @@ xfs_rui_log_format_sizeof( + * size is given by rud_nextents; + */ + struct xfs_rud_log_format { +- __uint16_t rud_type; /* rud log item type */ +- __uint16_t rud_size; /* size of this item */ +- __uint32_t __pad; +- __uint64_t rud_rui_id; /* id of corresponding rui */ ++ uint16_t rud_type; /* rud log item type */ ++ uint16_t rud_size; /* size of this item */ ++ uint32_t __pad; ++ uint64_t rud_rui_id; /* id of corresponding rui */ + }; + + /* + * CUI/CUD (refcount update) log format definitions + */ + struct xfs_phys_extent { +- __uint64_t pe_startblock; +- __uint32_t pe_len; +- __uint32_t pe_flags; ++ uint64_t pe_startblock; ++ uint32_t pe_len; ++ uint32_t pe_flags; + }; + + /* refcount pe_flags: upper bits are flags, lower byte is type code */ +@@ -707,10 +707,10 @@ struct xfs_phys_extent { + * size is given by cui_nextents. + */ + struct xfs_cui_log_format { +- __uint16_t cui_type; /* cui log item type */ +- __uint16_t cui_size; /* size of this item */ +- __uint32_t cui_nextents; /* # extents to free */ +- __uint64_t cui_id; /* cui identifier */ ++ uint16_t cui_type; /* cui log item type */ ++ uint16_t cui_size; /* size of this item */ ++ uint32_t cui_nextents; /* # extents to free */ ++ uint64_t cui_id; /* cui identifier */ + struct xfs_phys_extent cui_extents[]; /* array of extents */ + }; + +@@ -728,10 +728,10 @@ xfs_cui_log_format_sizeof( + * size is given by cud_nextents; + */ + struct xfs_cud_log_format { +- __uint16_t cud_type; /* cud log item type */ +- __uint16_t cud_size; /* size of this item */ +- __uint32_t __pad; +- __uint64_t cud_cui_id; /* id of corresponding cui */ ++ uint16_t cud_type; /* cud log item type */ ++ uint16_t cud_size; /* size of this item */ ++ uint32_t __pad; ++ uint64_t cud_cui_id; /* id of corresponding cui */ + }; + + /* +@@ -755,10 +755,10 @@ struct xfs_cud_log_format { + * size is given by bui_nextents. + */ + struct xfs_bui_log_format { +- __uint16_t bui_type; /* bui log item type */ +- __uint16_t bui_size; /* size of this item */ +- __uint32_t bui_nextents; /* # extents to free */ +- __uint64_t bui_id; /* bui identifier */ ++ uint16_t bui_type; /* bui log item type */ ++ uint16_t bui_size; /* size of this item */ ++ uint32_t bui_nextents; /* # extents to free */ ++ uint64_t bui_id; /* bui identifier */ + struct xfs_map_extent bui_extents[]; /* array of extents to bmap */ + }; + +@@ -776,10 +776,10 @@ xfs_bui_log_format_sizeof( + * size is given by bud_nextents; + */ + struct xfs_bud_log_format { +- __uint16_t bud_type; /* bud log item type */ +- __uint16_t bud_size; /* size of this item */ +- __uint32_t __pad; +- __uint64_t bud_bui_id; /* id of corresponding bui */ ++ uint16_t bud_type; /* bud log item type */ ++ uint16_t bud_size; /* size of this item */ ++ uint32_t __pad; ++ uint64_t bud_bui_id; /* id of corresponding bui */ + }; + + /* +@@ -789,12 +789,12 @@ struct xfs_bud_log_format { + * 32 bits : log_recovery code assumes that. + */ + typedef struct xfs_dq_logformat { +- __uint16_t qlf_type; /* dquot log item type */ +- __uint16_t qlf_size; /* size of this item */ ++ uint16_t qlf_type; /* dquot log item type */ ++ uint16_t qlf_size; /* size of this item */ + xfs_dqid_t qlf_id; /* usr/grp/proj id : 32 bits */ +- __int64_t qlf_blkno; /* blkno of dquot buffer */ +- __int32_t qlf_len; /* len of dquot buffer */ +- __uint32_t qlf_boffset; /* off of dquot in buffer */ ++ int64_t qlf_blkno; /* blkno of dquot buffer */ ++ int32_t qlf_len; /* len of dquot buffer */ ++ uint32_t qlf_boffset; /* off of dquot in buffer */ + } xfs_dq_logformat_t; + + /* +@@ -853,8 +853,8 @@ typedef struct xfs_qoff_logformat { + * decoding can be done correctly. + */ + struct xfs_icreate_log { +- __uint16_t icl_type; /* type of log format structure */ +- __uint16_t icl_size; /* size of log format structure */ ++ uint16_t icl_type; /* type of log format structure */ ++ uint16_t icl_size; /* size of log format structure */ + __be32 icl_ag; /* ag being allocated in */ + __be32 icl_agbno; /* start block of inode range */ + __be32 icl_count; /* number of inodes to initialise */ +diff --git a/libxfs/xfs_quota_defs.h b/libxfs/xfs_quota_defs.h +index 8eed512..d69c772 100644 +--- a/libxfs/xfs_quota_defs.h ++++ b/libxfs/xfs_quota_defs.h +@@ -27,8 +27,8 @@ + * they may need 64-bit accounting. Hence, 64-bit quota-counters, + * and quota-limits. This is a waste in the common case, but hey ... + */ +-typedef __uint64_t xfs_qcnt_t; +-typedef __uint16_t xfs_qwarncnt_t; ++typedef uint64_t xfs_qcnt_t; ++typedef uint16_t xfs_qwarncnt_t; + + /* + * flags for q_flags field in the dquot. +diff --git a/libxfs/xfs_refcount_btree.c b/libxfs/xfs_refcount_btree.c +index 2814f94..bd1a8f2 100644 +--- a/libxfs/xfs_refcount_btree.c ++++ b/libxfs/xfs_refcount_btree.c +@@ -201,7 +201,7 @@ xfs_refcountbt_init_ptr_from_cur( + ptr->s = agf->agf_refcount_root; + } + +-STATIC __int64_t ++STATIC int64_t + xfs_refcountbt_key_diff( + struct xfs_btree_cur *cur, + union xfs_btree_key *key) +@@ -209,16 +209,16 @@ xfs_refcountbt_key_diff( + struct xfs_refcount_irec *rec = &cur->bc_rec.rc; + struct xfs_refcount_key *kp = &key->refc; + +- return (__int64_t)be32_to_cpu(kp->rc_startblock) - rec->rc_startblock; ++ return (int64_t)be32_to_cpu(kp->rc_startblock) - rec->rc_startblock; + } + +-STATIC __int64_t ++STATIC int64_t + xfs_refcountbt_diff_two_keys( + struct xfs_btree_cur *cur, + union xfs_btree_key *k1, + union xfs_btree_key *k2) + { +- return (__int64_t)be32_to_cpu(k1->refc.rc_startblock) - ++ return (int64_t)be32_to_cpu(k1->refc.rc_startblock) - + be32_to_cpu(k2->refc.rc_startblock); + } + +diff --git a/libxfs/xfs_rmap.c b/libxfs/xfs_rmap.c +index f78771d..0d6b5d4 100644 +--- a/libxfs/xfs_rmap.c ++++ b/libxfs/xfs_rmap.c +@@ -2059,7 +2059,7 @@ int + xfs_rmap_finish_one( + struct xfs_trans *tp, + enum xfs_rmap_intent_type type, +- __uint64_t owner, ++ uint64_t owner, + int whichfork, + xfs_fileoff_t startoff, + xfs_fsblock_t startblock, +@@ -2180,7 +2180,7 @@ __xfs_rmap_add( + struct xfs_mount *mp, + struct xfs_defer_ops *dfops, + enum xfs_rmap_intent_type type, +- __uint64_t owner, ++ uint64_t owner, + int whichfork, + struct xfs_bmbt_irec *bmap) + { +@@ -2264,7 +2264,7 @@ xfs_rmap_alloc_extent( + xfs_agnumber_t agno, + xfs_agblock_t bno, + xfs_extlen_t len, +- __uint64_t owner) ++ uint64_t owner) + { + struct xfs_bmbt_irec bmap; + +@@ -2288,7 +2288,7 @@ xfs_rmap_free_extent( + xfs_agnumber_t agno, + xfs_agblock_t bno, + xfs_extlen_t len, +- __uint64_t owner) ++ uint64_t owner) + { + struct xfs_bmbt_irec bmap; + +diff --git a/libxfs/xfs_rmap.h b/libxfs/xfs_rmap.h +index 98f908f..265116d 100644 +--- a/libxfs/xfs_rmap.h ++++ b/libxfs/xfs_rmap.h +@@ -179,7 +179,7 @@ enum xfs_rmap_intent_type { + struct xfs_rmap_intent { + struct list_head ri_list; + enum xfs_rmap_intent_type ri_type; +- __uint64_t ri_owner; ++ uint64_t ri_owner; + int ri_whichfork; + struct xfs_bmbt_irec ri_bmap; + }; +@@ -196,15 +196,15 @@ int xfs_rmap_convert_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops, + struct xfs_bmbt_irec *imap); + int xfs_rmap_alloc_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops, + xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len, +- __uint64_t owner); ++ uint64_t owner); + int xfs_rmap_free_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops, + xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len, +- __uint64_t owner); ++ uint64_t owner); + + void xfs_rmap_finish_one_cleanup(struct xfs_trans *tp, + struct xfs_btree_cur *rcur, int error); + int xfs_rmap_finish_one(struct xfs_trans *tp, enum xfs_rmap_intent_type type, +- __uint64_t owner, int whichfork, xfs_fileoff_t startoff, ++ uint64_t owner, int whichfork, xfs_fileoff_t startoff, + xfs_fsblock_t startblock, xfs_filblks_t blockcount, + xfs_exntst_t state, struct xfs_btree_cur **pcur); + +diff --git a/libxfs/xfs_rmap_btree.c b/libxfs/xfs_rmap_btree.c +index a186c87..9a0c087 100644 +--- a/libxfs/xfs_rmap_btree.c ++++ b/libxfs/xfs_rmap_btree.c +@@ -197,7 +197,7 @@ xfs_rmapbt_init_high_key_from_rec( + union xfs_btree_key *key, + union xfs_btree_rec *rec) + { +- __uint64_t off; ++ uint64_t off; + int adj; + + adj = be32_to_cpu(rec->rmap.rm_blockcount) - 1; +@@ -239,7 +239,7 @@ xfs_rmapbt_init_ptr_from_cur( + ptr->s = agf->agf_roots[cur->bc_btnum]; + } + +-STATIC __int64_t ++STATIC int64_t + xfs_rmapbt_key_diff( + struct xfs_btree_cur *cur, + union xfs_btree_key *key) +@@ -247,9 +247,9 @@ xfs_rmapbt_key_diff( + struct xfs_rmap_irec *rec = &cur->bc_rec.r; + struct xfs_rmap_key *kp = &key->rmap; + __u64 x, y; +- __int64_t d; ++ int64_t d; + +- d = (__int64_t)be32_to_cpu(kp->rm_startblock) - rec->rm_startblock; ++ d = (int64_t)be32_to_cpu(kp->rm_startblock) - rec->rm_startblock; + if (d) + return d; + +@@ -269,7 +269,7 @@ xfs_rmapbt_key_diff( + return 0; + } + +-STATIC __int64_t ++STATIC int64_t + xfs_rmapbt_diff_two_keys( + struct xfs_btree_cur *cur, + union xfs_btree_key *k1, +@@ -277,10 +277,10 @@ xfs_rmapbt_diff_two_keys( + { + struct xfs_rmap_key *kp1 = &k1->rmap; + struct xfs_rmap_key *kp2 = &k2->rmap; +- __int64_t d; ++ int64_t d; + __u64 x, y; + +- d = (__int64_t)be32_to_cpu(kp1->rm_startblock) - ++ d = (int64_t)be32_to_cpu(kp1->rm_startblock) - + be32_to_cpu(kp2->rm_startblock); + if (d) + return d; +@@ -382,10 +382,10 @@ xfs_rmapbt_keys_inorder( + union xfs_btree_key *k1, + union xfs_btree_key *k2) + { +- __uint32_t x; +- __uint32_t y; +- __uint64_t a; +- __uint64_t b; ++ uint32_t x; ++ uint32_t y; ++ uint64_t a; ++ uint64_t b; + + x = be32_to_cpu(k1->rmap.rm_startblock); + y = be32_to_cpu(k2->rmap.rm_startblock); +@@ -412,10 +412,10 @@ xfs_rmapbt_recs_inorder( + union xfs_btree_rec *r1, + union xfs_btree_rec *r2) + { +- __uint32_t x; +- __uint32_t y; +- __uint64_t a; +- __uint64_t b; ++ uint32_t x; ++ uint32_t y; ++ uint64_t a; ++ uint64_t b; + + x = be32_to_cpu(r1->rmap.rm_startblock); + y = be32_to_cpu(r2->rmap.rm_startblock); +diff --git a/libxfs/xfs_rtbitmap.c b/libxfs/xfs_rtbitmap.c +index dbd2f88..8f8a99d 100644 +--- a/libxfs/xfs_rtbitmap.c ++++ b/libxfs/xfs_rtbitmap.c +@@ -1006,7 +1006,7 @@ xfs_rtfree_extent( + mp->m_sb.sb_rextents) { + if (!(mp->m_rbmip->i_d.di_flags & XFS_DIFLAG_NEWRTBM)) + mp->m_rbmip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM; +- *(__uint64_t *)&VFS_I(mp->m_rbmip)->i_atime = 0; ++ *(uint64_t *)&VFS_I(mp->m_rbmip)->i_atime = 0; + xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE); + } + return 0; +diff --git a/libxfs/xfs_sb.c b/libxfs/xfs_sb.c +index 93a1819..51f6970 100644 +--- a/libxfs/xfs_sb.c ++++ b/libxfs/xfs_sb.c +@@ -430,7 +430,7 @@ xfs_sb_quota_to_disk( + struct xfs_dsb *to, + struct xfs_sb *from) + { +- __uint16_t qflags = from->sb_qflags; ++ uint16_t qflags = from->sb_qflags; + + to->sb_uquotino = cpu_to_be64(from->sb_uquotino); + if (xfs_sb_version_has_pquotino(from)) { +@@ -738,7 +738,7 @@ xfs_sb_mount_common( + mp->m_refc_mnr[1] = mp->m_refc_mxr[1] / 2; + + mp->m_bsize = XFS_FSB_TO_BB(mp, 1); +- mp->m_ialloc_inos = (int)MAX((__uint16_t)XFS_INODES_PER_CHUNK, ++ mp->m_ialloc_inos = (int)MAX((uint16_t)XFS_INODES_PER_CHUNK, + sbp->sb_inopblock); + mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog; + +diff --git a/libxfs/xfs_types.h b/libxfs/xfs_types.h +index 717909f..6543ac7 100644 +--- a/libxfs/xfs_types.h ++++ b/libxfs/xfs_types.h +@@ -18,34 +18,34 @@ + #ifndef __XFS_TYPES_H__ + #define __XFS_TYPES_H__ + +-typedef __uint32_t prid_t; /* project ID */ ++typedef uint32_t prid_t; /* project ID */ + +-typedef __uint32_t xfs_agblock_t; /* blockno in alloc. group */ +-typedef __uint32_t xfs_agino_t; /* inode # within allocation grp */ +-typedef __uint32_t xfs_extlen_t; /* extent length in blocks */ +-typedef __uint32_t xfs_agnumber_t; /* allocation group number */ +-typedef __int32_t xfs_extnum_t; /* # of extents in a file */ +-typedef __int16_t xfs_aextnum_t; /* # extents in an attribute fork */ +-typedef __int64_t xfs_fsize_t; /* bytes in a file */ +-typedef __uint64_t xfs_ufsize_t; /* unsigned bytes in a file */ ++typedef uint32_t xfs_agblock_t; /* blockno in alloc. group */ ++typedef uint32_t xfs_agino_t; /* inode # within allocation grp */ ++typedef uint32_t xfs_extlen_t; /* extent length in blocks */ ++typedef uint32_t xfs_agnumber_t; /* allocation group number */ ++typedef int32_t xfs_extnum_t; /* # of extents in a file */ ++typedef int16_t xfs_aextnum_t; /* # extents in an attribute fork */ ++typedef int64_t xfs_fsize_t; /* bytes in a file */ ++typedef uint64_t xfs_ufsize_t; /* unsigned bytes in a file */ + +-typedef __int32_t xfs_suminfo_t; /* type of bitmap summary info */ +-typedef __int32_t xfs_rtword_t; /* word type for bitmap manipulations */ ++typedef int32_t xfs_suminfo_t; /* type of bitmap summary info */ ++typedef int32_t xfs_rtword_t; /* word type for bitmap manipulations */ + +-typedef __int64_t xfs_lsn_t; /* log sequence number */ +-typedef __int32_t xfs_tid_t; /* transaction identifier */ ++typedef int64_t xfs_lsn_t; /* log sequence number */ ++typedef int32_t xfs_tid_t; /* transaction identifier */ + +-typedef __uint32_t xfs_dablk_t; /* dir/attr block number (in file) */ +-typedef __uint32_t xfs_dahash_t; /* dir/attr hash value */ ++typedef uint32_t xfs_dablk_t; /* dir/attr block number (in file) */ ++typedef uint32_t xfs_dahash_t; /* dir/attr hash value */ + +-typedef __uint64_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */ +-typedef __uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */ +-typedef __uint64_t xfs_rtblock_t; /* extent (block) in realtime area */ +-typedef __uint64_t xfs_fileoff_t; /* block number in a file */ +-typedef __uint64_t xfs_filblks_t; /* number of blocks in a file */ ++typedef uint64_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */ ++typedef uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */ ++typedef uint64_t xfs_rtblock_t; /* extent (block) in realtime area */ ++typedef uint64_t xfs_fileoff_t; /* block number in a file */ ++typedef uint64_t xfs_filblks_t; /* number of blocks in a file */ + +-typedef __int64_t xfs_srtblock_t; /* signed version of xfs_rtblock_t */ +-typedef __int64_t xfs_sfiloff_t; /* signed block number in a file */ ++typedef int64_t xfs_srtblock_t; /* signed version of xfs_rtblock_t */ ++typedef int64_t xfs_sfiloff_t; /* signed block number in a file */ + + /* + * Null values for the types. +@@ -125,7 +125,7 @@ struct xfs_name { + * uid_t and gid_t are hard-coded to 32 bits in the inode. + * Hence, an 'id' in a dquot is 32 bits.. + */ +-typedef __uint32_t xfs_dqid_t; ++typedef uint32_t xfs_dqid_t; + + /* + * Constants for bit manipulations. +-- +2.14.1 + diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/link_needed_libs.patch b/meta-filesystems/recipes-utils/xfsprogs/files/link_needed_libs.patch deleted file mode 100644 index 1de634ed7..000000000 --- a/meta-filesystems/recipes-utils/xfsprogs/files/link_needed_libs.patch +++ /dev/null @@ -1,82 +0,0 @@ -Index: xfsprogs-4.10.0/libxcmd/Makefile -=================================================================== ---- xfsprogs-4.10.0.orig/libxcmd/Makefile -+++ xfsprogs-4.10.0/libxcmd/Makefile -@@ -30,10 +30,21 @@ LCFLAGS += -DENABLE_EDITLINE - LTLIBS += $(LIBEDITLINE) $(LIBTERMCAP) - endif - -+ifeq ($(ENABLE_BLKID),yes) -+LCFLAGS += -DENABLE_BLKID -+LTLIBS += $(LIBBLKID) -+endif -+ -+LTLIBS += $(LIBXFS) -+ - default: ltdepend $(LTLIBRARY) - - include $(BUILDRULES) - --install install-dev: default -+install: default -+ $(INSTALL_LTLIB) -+ -+install-dev: default -+ $(INSTALL_LTLIB_DEV) - - -include .ltdep -Index: xfsprogs-4.10.0/libxfs/Makefile -=================================================================== ---- xfsprogs-4.10.0.orig/libxfs/Makefile -+++ xfsprogs-4.10.0/libxfs/Makefile -@@ -137,6 +137,7 @@ include $(BUILDRULES) - - install: default - $(INSTALL) -m 755 -d $(PKG_INC_DIR) -+ $(INSTALL_LTLIB) - - install-headers: $(addsuffix -hdrs, $(PKGHFILES)) - -Index: xfsprogs-4.10.0/libxlog/Makefile -=================================================================== ---- xfsprogs-4.10.0.orig/libxlog/Makefile -+++ xfsprogs-4.10.0/libxlog/Makefile -@@ -19,6 +19,10 @@ default: ltdepend $(LTLIBRARY) - - include $(BUILDRULES) - --install install-dev: default -+install: default -+ $(INSTALL_LTLIB) -+ -+install-dev: default -+ $(INSTALL_LTLIB_DEV) - - -include .ltdep -Index: xfsprogs-4.10.0/io/Makefile -=================================================================== ---- xfsprogs-4.10.0.orig/io/Makefile -+++ xfsprogs-4.10.0/io/Makefile -@@ -13,7 +13,7 @@ - getrusage.c imap.c link.c mmap.c open.c parent.c pread.c prealloc.c \ - pwrite.c reflink.c seek.c shutdown.c sync.c truncate.c utimes.c - --LLDLIBS = $(LIBXCMD) $(LIBHANDLE) $(LIBPTHREAD) -+LLDLIBS = $(LIBXCMD) $(LIBHANDLE) $(LIBUUID) $(LIBPTHREAD) - LTDEPENDENCIES = $(LIBXCMD) $(LIBHANDLE) - LLDFLAGS = -static-libtool-libs - -Index: xfsprogs-4.10.0/quota/Makefile -=================================================================== ---- xfsprogs-4.10.0.orig/quota/Makefile -+++ xfsprogs-4.10.0/quotq/Makefile -@@ -14,7 +14,7 @@ - PCFILES = darwin.c freebsd.c irix.c linux.c - LSRCFILES = $(shell echo $(PCFILES) | sed -e "s/$(PKG_PLATFORM).c//g") - --LLDLIBS = $(LIBXCMD) -+LLDLIBS = $(LIBXCMD) $(LIBUUID) - LTDEPENDENCIES = $(LIBXCMD) - LLDFLAGS = -static - - diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/remove_flags_from_build_flags.patch b/meta-filesystems/recipes-utils/xfsprogs/files/remove_flags_from_build_flags.patch new file mode 100644 index 000000000..bba9a25c2 --- /dev/null +++ b/meta-filesystems/recipes-utils/xfsprogs/files/remove_flags_from_build_flags.patch @@ -0,0 +1,13 @@ +Index: xfsprogs-4.12.0/include/builddefs.in +=================================================================== +--- xfsprogs-4.12.0.orig/include/builddefs.in ++++ xfsprogs-4.12.0/include/builddefs.in +@@ -164,7 +164,7 @@ ifeq ($(ENABLE_GETTEXT),yes) + GCFLAGS += -DENABLE_GETTEXT + endif + +-BUILD_CFLAGS += $(GCFLAGS) $(PCFLAGS) ++BUILD_CFLAGS += $(GCFLAGS) + # First, Global, Platform, Local CFLAGS + CFLAGS += $(FCFLAGS) $(OPTIMIZER) $(GCFLAGS) $(PCFLAGS) $(LCFLAGS) + diff --git a/meta-filesystems/recipes-utils/xfsprogs/files/xfsprogs-4.12.0-fix_musl.patch b/meta-filesystems/recipes-utils/xfsprogs/files/xfsprogs-4.12.0-fix_musl.patch new file mode 100644 index 000000000..efc57e4f6 --- /dev/null +++ b/meta-filesystems/recipes-utils/xfsprogs/files/xfsprogs-4.12.0-fix_musl.patch @@ -0,0 +1,117 @@ +From 21253610f9ef87db8e2a75b863b7fcfbd0cdb421 Mon Sep 17 00:00:00 2001 +From: "Darrick J. Wong" +Date: Tue, 25 Jul 2017 13:45:01 -0500 +Subject: [PATCH] In patch 4944defad4 ("xfs_db: redirect printfs when + metadumping to stdout"), we solved the problem of xfs_db printfs ending up in + the metadump stream by reassigning stdout for the duration of a stdout + metadump. Unfortunately, musl doesn't allow stdout to be reassigned (in + their view "extern FILE *stdout" means "extern FILE * const stdout"), so we + abandon the old approach in favor of playing games with dup() to switch the + raw file descriptors. + +While we're at it, fix a regression where an unconverted outf test +allows progress info to end up in the metadump stream. + +Signed-off-by: Darrick J. Wong +--- + db/metadump.c | 47 ++++++++++++++++++++++++++++++++++++----------- + 1 file changed, 36 insertions(+), 11 deletions(-) + +diff --git a/db/metadump.c b/db/metadump.c +index 96641e0..4e2f648 100644 +--- a/db/metadump.c ++++ b/db/metadump.c +@@ -78,6 +78,7 @@ static int obfuscate = 1; + static int zero_stale_data = 1; + static int show_warnings = 0; + static int progress_since_warning = 0; ++static bool stdout_metadump; + + void + metadump_init(void) +@@ -137,7 +138,7 @@ print_progress(const char *fmt, ...) + va_end(ap); + buf[sizeof(buf)-1] = '\0'; + +- f = (outf == stdout) ? stderr : stdout; ++ f = stdout_metadump ? stderr : stdout; + fprintf(f, "\r%-59s", buf); + fflush(f); + progress_since_warning = 1; +@@ -2750,7 +2751,8 @@ metadump_f( + xfs_agnumber_t agno; + int c; + int start_iocur_sp; +- bool stdout_metadump = false; ++ int outfd = -1; ++ int ret; + char *p; + + exitcode = 1; +@@ -2870,16 +2872,35 @@ metadump_f( + * metadump operation so that dbprintf and other messages + * are sent to the console instead of polluting the + * metadump stream. ++ * ++ * We get to do this the hard way because musl doesn't ++ * allow reassignment of stdout. + */ +- outf = stdout; +- stdout = stderr; ++ fflush(stdout); ++ outfd = dup(STDOUT_FILENO); ++ if (outfd < 0) { ++ perror("opening dump stream"); ++ goto out; ++ } ++ ret = dup2(STDERR_FILENO, STDOUT_FILENO); ++ if (ret < 0) { ++ perror("redirecting stdout"); ++ close(outfd); ++ goto out; ++ } ++ outf = fdopen(outfd, "a"); ++ if (outf == NULL) { ++ fprintf(stderr, "cannot create dump stream\n"); ++ dup2(outfd, 1); ++ close(outfd); ++ goto out; ++ } + stdout_metadump = true; + } else { + outf = fopen(argv[optind], "wb"); + if (outf == NULL) { + print_warning("cannot create dump file"); +- free(metablock); +- return 0; ++ goto out; + } + } + +@@ -2907,15 +2928,19 @@ metadump_f( + if (progress_since_warning) + fputc('\n', stdout_metadump ? stderr : stdout); + +- if (stdout_metadump) +- stdout = outf; +- else +- fclose(outf); ++ if (stdout_metadump) { ++ fflush(outf); ++ fflush(stdout); ++ ret = dup2(outfd, STDOUT_FILENO); ++ if (ret < 0) ++ perror("un-redirecting stdout"); ++ } ++ fclose(outf); + + /* cleanup iocur stack */ + while (iocur_sp > start_iocur_sp) + pop_cur(); +- ++out: + free(metablock); + + return 0; +-- +2.13.3 diff --git a/meta-filesystems/recipes-utils/xfsprogs/xfsprogs_4.11.0.bb b/meta-filesystems/recipes-utils/xfsprogs/xfsprogs_4.12.0.bb similarity index 79% rename from meta-filesystems/recipes-utils/xfsprogs/xfsprogs_4.11.0.bb rename to meta-filesystems/recipes-utils/xfsprogs/xfsprogs_4.12.0.bb index 046dea425..1ccb2a71a 100644 --- a/meta-filesystems/recipes-utils/xfsprogs/xfsprogs_4.11.0.bb +++ b/meta-filesystems/recipes-utils/xfsprogs/xfsprogs_4.12.0.bb @@ -6,11 +6,13 @@ LICENSE_libhandle = "LGPLv2.1" LIC_FILES_CHKSUM = "file://doc/COPYING;md5=102f7fec3d53c7c8f0b7baf9bf9d76a8" DEPENDS = "util-linux util-linux-native" SRC_URI = "https://www.kernel.org/pub/linux/utils/fs/xfs/xfsprogs/${BP}.tar.xz \ - file://link_needed_libs.patch \ - file://0001-define-__-prefixed-version-of-intXY_t-types.patch \ + file://0001-xfsprogs-remove-double-underscore-integer-types.patch \ + file://0001-xfsprogs-remove-remaining-double-underscore-integer-.patch \ + file://remove_flags_from_build_flags.patch \ + file://xfsprogs-4.12.0-fix_musl.patch \ " -SRC_URI[md5sum] = "f1f9b8c752347eefdb56483dafa0cefb" -SRC_URI[sha256sum] = "c3a6d87b564d7738243c507df82276bed982265e345363a95f2c764e8a5f5bb2" +SRC_URI[md5sum] = "e348b0e1d7bd1cd82d64b91ff37e727e" +SRC_URI[sha256sum] = "b330ad8d737f4152ae511580102e2fc49212bb51dfb4b614084344abae46d0df" inherit autotools-brokensep @@ -33,6 +35,7 @@ EXTRA_OECONF = "--enable-gettext=no \ ac_cv_lib_rt_lio_listio=yes \ " +DISABLE_STATIC = "" EXTRA_AUTORECONF += "-I ${S}/m4 --exclude=autoheader" PACKAGECONFIG ??= "readline blkid" @@ -42,6 +45,7 @@ PACKAGECONFIG[blkid] = "--enable-blkid=yes,--enable-blkid=no,util-linux" export DEBUG="-DNDEBUG" export BUILD_VERBOSE="1" +export tagname="CC" EXTRA_OEMAKE = "DIST_ROOT='${D}'"