* [PATCH 1/6] Move from __uint*_t types to uint*_t and likewise for __int*_t
[not found] <cover.1452627740.git.felix.janda@posteo.de>
@ 2016-01-12 19:59 ` Felix Janda
2016-01-12 21:24 ` Dave Chinner
2016-01-12 19:59 ` [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat Felix Janda
` (4 subsequent siblings)
5 siblings, 1 reply; 31+ messages in thread
From: Felix Janda @ 2016-01-12 19:59 UTC (permalink / raw)
To: xfs
The uint*_t and int*_t are defined by C99 and should be prefered
over the less portable __uint*_t and __int*_t variants. The
necessary <stdint.h> include is in platformdefs.h, which gets
included in most places via libxfs.h. In the public headers
<stdint.h> is included in <xfs/xfs_types.h>.
Signed-off-by: Felix Janda <felix.janda@posteo.de>
---
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 | 30 ++++----
db/io.c | 4 +-
db/io.h | 8 +-
db/metadump.c | 12 +--
db/sb.c | 6 +-
fsr/xfs_fsr.c | 2 +-
include/darwin.h | 9 ---
include/freebsd.h | 6 +-
include/gnukfreebsd.h | 6 +-
include/irix.h | 28 +++----
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 | 20 ++---
libhandle/handle.c | 2 +-
libhandle/jdm.c | 2 +-
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 | 14 ++--
libxfs/xfs_alloc_btree.c | 10 +--
libxfs/xfs_attr_remote.c | 8 +-
libxfs/xfs_attr_sf.h | 18 ++---
libxfs/xfs_bit.h | 24 +++---
libxfs/xfs_bmap_btree.c | 8 +-
libxfs/xfs_btree.c | 12 +--
libxfs/xfs_btree.h | 14 ++--
libxfs/xfs_cksum.h | 14 ++--
libxfs/xfs_da_btree.c | 2 +-
libxfs/xfs_da_btree.h | 8 +-
libxfs/xfs_da_format.c | 24 +++---
libxfs/xfs_da_format.h | 60 +++++++--------
libxfs/xfs_dir2.h | 8 +-
libxfs/xfs_dir2_leaf.c | 12 +--
libxfs/xfs_dir2_priv.h | 2 +-
libxfs/xfs_format.h | 98 ++++++++++++------------
libxfs/xfs_fs.h | 12 +--
libxfs/xfs_ialloc.c | 6 +-
libxfs/xfs_ialloc_btree.c | 4 +-
libxfs/xfs_inode_buf.c | 2 +-
libxfs/xfs_log_format.h | 190 +++++++++++++++++++++++-----------------------
libxfs/xfs_quota_defs.h | 4 +-
libxfs/xfs_rtbitmap.c | 2 +-
libxfs/xfs_sb.c | 4 +-
libxfs/xfs_types.h | 46 +++++------
logprint/log_misc.c | 6 +-
mdrestore/xfs_mdrestore.c | 2 +-
mkfs/proto.c | 2 +-
mkfs/xfs_mkfs.c | 88 ++++++++++-----------
quota/edit.c | 64 ++++++++--------
quota/free.c | 44 +++++------
quota/quot.c | 24 +++---
quota/quota.c | 4 +-
quota/quota.h | 12 +--
quota/report.c | 2 +-
quota/state.c | 2 +-
quota/util.c | 66 ++++++++--------
repair/README | 2 +-
| 14 ++--
repair/attr_repair.h | 26 +++----
repair/avl64.c | 38 +++++-----
repair/avl64.h | 18 ++---
repair/dino_chunks.c | 2 +-
repair/dinode.c | 38 +++++-----
repair/dinode.h | 4 +-
repair/dir2.c | 2 +-
repair/globals.h | 16 ++--
repair/incore.c | 10 +--
repair/incore.h | 42 +++++-----
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 | 40 +++++-----
repair/phase6.c | 18 ++---
repair/phase7.c | 6 +-
repair/progress.c | 30 ++++----
repair/progress.h | 4 +-
repair/sb.c | 10 +--
repair/scan.c | 42 +++++-----
repair/scan.h | 12 +--
103 files changed, 870 insertions(+), 883 deletions(-)
diff --git a/copy/xfs_copy.c b/copy/xfs_copy.c
index 15a3f33..425cd7a 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;
@@ -303,7 +303,7 @@ usage(void)
}
void
-init_bar(__uint64_t source_blocks)
+init_bar(uint64_t source_blocks)
{
int i;
@@ -312,7 +312,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% ",
@@ -522,8 +522,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;
@@ -939,8 +939,8 @@ main(int argc, char **argv)
num_ags = mp->m_sb.sb_agcount;
init_bar(mp->m_sb.sb_blocksize / BBSIZE
- * ((__uint64_t)mp->m_sb.sb_dblocks
- - (__uint64_t)mp->m_sb.sb_fdblocks + 10 * num_ags));
+ * ((uint64_t)mp->m_sb.sb_dblocks
+ - (uint64_t)mp->m_sb.sb_fdblocks + 10 * num_ags));
kids = num_targets;
diff --git a/copy/xfs_copy.h b/copy/xfs_copy.h
index 2737068..53c6e42 100644
--- a/copy/xfs_copy.h
+++ b/copy/xfs_copy.h
@@ -76,7 +76,7 @@ typedef struct {
typedef int thread_id;
typedef int tm_index; /* index into thread mask array */
-typedef __uint32_t thread_mask; /* a thread mask */
+typedef uint32_t thread_mask; /* a thread mask */
typedef struct {
char *name;
diff --git a/db/attr.c b/db/attr.c
index e26ac67..6f56953 100644
--- a/db/attr.c
+++ b/db/attr.c
@@ -77,16 +77,16 @@ const field_t attr_leaf_entry_flds[] = {
{ "nameidx", FLDT_UINT16D, OI(LEOFF(nameidx)), C1, 0, TYP_NONE },
{ "flags", FLDT_UINT8X, OI(LEOFF(flags)), C1, FLD_SKIPALL, TYP_NONE },
{ "incomplete", FLDT_UINT1,
- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_INCOMPLETE_BIT - 1), C1,
+ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_INCOMPLETE_BIT - 1), C1,
0, TYP_NONE },
{ "root", FLDT_UINT1,
- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0,
+ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0,
TYP_NONE },
{ "secure", FLDT_UINT1,
- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0,
+ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0,
TYP_NONE },
{ "local", FLDT_UINT1,
- OI(LEOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_LOCAL_BIT - 1), C1, 0,
+ OI(LEOFF(flags) + bitsz(uint8_t) - XFS_ATTR_LOCAL_BIT - 1), C1, 0,
TYP_NONE },
{ "pad2", FLDT_UINT8X, OI(LEOFF(pad2)), C1, FLD_SKIPALL, TYP_NONE },
{ NULL }
diff --git a/db/attrshort.c b/db/attrshort.c
index d82559c..2ef358f 100644
--- a/db/attrshort.c
+++ b/db/attrshort.c
@@ -51,10 +51,10 @@ const field_t attr_sf_entry_flds[] = {
{ "valuelen", FLDT_UINT8D, OI(EOFF(valuelen)), C1, 0, TYP_NONE },
{ "flags", FLDT_UINT8X, OI(EOFF(flags)), C1, FLD_SKIPALL, TYP_NONE },
{ "root", FLDT_UINT1,
- OI(EOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0,
+ OI(EOFF(flags) + bitsz(uint8_t) - XFS_ATTR_ROOT_BIT - 1), C1, 0,
TYP_NONE },
{ "secure", FLDT_UINT1,
- OI(EOFF(flags) + bitsz(__uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0,
+ OI(EOFF(flags) + bitsz(uint8_t) - XFS_ATTR_SECURE_BIT - 1), C1, 0,
TYP_NONE },
{ "name", FLDT_CHARNS, OI(EOFF(nameval)), attr_sf_entry_name_count,
FLD_COUNT, TYP_NONE },
diff --git a/db/bit.c b/db/bit.c
index 24872bf..53cbcb3 100644
--- a/db/bit.c
+++ b/db/bit.c
@@ -60,7 +60,7 @@ setbit(
}
}
-__int64_t
+int64_t
getbitval(
void *obj,
int bitoff,
@@ -70,7 +70,7 @@ getbitval(
int bit;
int i;
char *p;
- __int64_t rval;
+ int64_t rval;
int signext;
int z1, z2, z3, z4;
diff --git a/db/bit.h b/db/bit.h
index 80ba24c..7601066 100644
--- a/db/bit.h
+++ b/db/bit.h
@@ -25,5 +25,5 @@
#define BVUNSIGNED 0
#define BVSIGNED 1
-extern __int64_t getbitval(void *obj, int bitoff, int nbits, int flags);
+extern int64_t getbitval(void *obj, int bitoff, int nbits, int flags);
extern void setbitval(void *obuf, int bitoff, int nbits, void *ibuf);
diff --git a/db/block.c b/db/block.c
index 4a357ce..77b9054 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 838db53..8ffa156 100644
--- a/db/check.c
+++ b/db/check.c
@@ -112,8 +112,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;
@@ -122,10 +122,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;
@@ -1173,7 +1173,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;
@@ -2991,7 +2991,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)
@@ -3004,7 +3004,7 @@ process_leaf_node_dir_v2(
if (!sflag || v)
dbprintf(_("can't read block %u for directory "
"inode %lld\n"),
- (__uint32_t)dbno, id->ino);
+ (uint32_t)dbno, id->ino);
error++;
pop_cur();
dbno += mp->m_dir_geo->fsbcount - 1;
diff --git a/db/convert.c b/db/convert.c
index a337abe..fa4f962 100644
--- a/db/convert.c
+++ b/db/convert.c
@@ -24,13 +24,13 @@
#define M(A) (1 << CT_ ## A)
#define agblock_to_bytes(x) \
- ((__uint64_t)(x) << mp->m_sb.sb_blocklog)
+ ((uint64_t)(x) << mp->m_sb.sb_blocklog)
#define agino_to_bytes(x) \
- ((__uint64_t)(x) << mp->m_sb.sb_inodelog)
+ ((uint64_t)(x) << mp->m_sb.sb_inodelog)
#define agnumber_to_bytes(x) \
- agblock_to_bytes((__uint64_t)(x) * mp->m_sb.sb_agblocks)
+ agblock_to_bytes((uint64_t)(x) * mp->m_sb.sb_agblocks)
#define daddr_to_bytes(x) \
- ((__uint64_t)(x) << BBSHIFT)
+ ((uint64_t)(x) << BBSHIFT)
#define fsblock_to_bytes(x) \
(agnumber_to_bytes(XFS_FSB_TO_AGNO(mp, (x))) + \
agblock_to_bytes(XFS_FSB_TO_AGBNO(mp, (x))))
@@ -38,7 +38,7 @@
(agnumber_to_bytes(XFS_INO_TO_AGNO(mp, (x))) + \
agino_to_bytes(XFS_INO_TO_AGINO(mp, (x))))
#define inoidx_to_bytes(x) \
- ((__uint64_t)(x) << mp->m_sb.sb_inodelog)
+ ((uint64_t)(x) << mp->m_sb.sb_inodelog)
typedef enum {
CT_NONE = -1,
@@ -68,7 +68,7 @@ typedef union {
xfs_agnumber_t agnumber;
int bboff;
int blkoff;
- __uint64_t byte;
+ uint64_t byte;
xfs_daddr_t daddr;
xfs_fsblock_t fsblock;
xfs_ino_t ino;
@@ -76,7 +76,7 @@ typedef union {
int inooff;
} cval_t;
-static __uint64_t bytevalue(ctype_t ctype, cval_t *val);
+static uint64_t bytevalue(ctype_t ctype, cval_t *val);
static int convert_f(int argc, char **argv);
static int getvalue(char *s, ctype_t ctype, cval_t *val);
static ctype_t lookupcty(char *ctyname);
@@ -118,7 +118,7 @@ static const cmdinfo_t convert_cmd =
{ "convert", NULL, convert_f, 3, 9, 0, "type num [type num]... type",
"convert from one address form to another", NULL };
-static __uint64_t
+static uint64_t
bytevalue(ctype_t ctype, cval_t *val)
{
switch (ctype) {
@@ -129,9 +129,9 @@ bytevalue(ctype_t ctype, cval_t *val)
case CT_AGNUMBER:
return agnumber_to_bytes(val->agnumber);
case CT_BBOFF:
- return (__uint64_t)val->bboff;
+ return (uint64_t)val->bboff;
case CT_BLKOFF:
- return (__uint64_t)val->blkoff;
+ return (uint64_t)val->blkoff;
case CT_BYTE:
return val->byte;
case CT_DADDR:
@@ -143,7 +143,7 @@ bytevalue(ctype_t ctype, cval_t *val)
case CT_INOIDX:
return inoidx_to_bytes(val->inoidx);
case CT_INOOFF:
- return (__uint64_t)val->inooff;
+ return (uint64_t)val->inooff;
case CT_NONE:
case NCTS:
break;
@@ -160,7 +160,7 @@ convert_f(int argc, char **argv)
cval_t cvals[NCTS] = {};
int i;
int mask;
- __uint64_t v;
+ uint64_t v;
ctype_t wtype;
/* move past the "convert" command */
@@ -262,7 +262,7 @@ static int
getvalue(char *s, ctype_t ctype, cval_t *val)
{
char *p;
- __uint64_t v;
+ uint64_t v;
v = strtoull(s, &p, 0);
if (*p != '\0') {
@@ -286,7 +286,7 @@ getvalue(char *s, ctype_t ctype, cval_t *val)
val->blkoff = (int)v;
break;
case CT_BYTE:
- val->byte = (__uint64_t)v;
+ val->byte = (uint64_t)v;
break;
case CT_DADDR:
val->daddr = (xfs_daddr_t)v;
diff --git a/db/faddr.c b/db/faddr.c
index e368d0d..6ded295 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 843c385..2c8d414 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 },
@@ -165,7 +165,7 @@ const ftattr_t ftattrtab[] = {
SI(bitsz(xfs_alloc_rec_t)), 0, NULL, cntbt_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 },
@@ -180,7 +180,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,
@@ -261,7 +261,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 },
@@ -301,15 +301,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 },
@@ -322,34 +322,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 f2b3794..12b1574 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 3beb416..c3d1581 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;
@@ -306,8 +306,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 442e6ea..3b2ee1a 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 }
diff --git a/db/io.c b/db/io.c
index 9452e07..8fa2504 100644
--- a/db/io.c
+++ b/db/io.c
@@ -487,7 +487,7 @@ write_cur(void)
void
set_cur(
const typ_t *t,
- __int64_t d,
+ int64_t d,
int c,
int ring_flag,
bbmap_t *bbmap)
@@ -495,7 +495,7 @@ set_cur(
struct xfs_buf *bp;
xfs_ino_t dirino;
xfs_ino_t ino;
- __uint16_t mode;
+ uint16_t mode;
const struct xfs_buf_ops *ops = t ? t->bops : NULL;
if (iocur_sp < 0) {
diff --git a/db/io.h b/db/io.h
index 6201d7b..4700db3 100644
--- a/db/io.h
+++ b/db/io.h
@@ -25,7 +25,7 @@ typedef struct bbmap {
} bbmap_t;
typedef struct iocur {
- __int64_t bb; /* BB number in filesystem of buf */
+ int64_t bb; /* BB number in filesystem of buf */
int blen; /* length of "buf", bb's */
int boff; /* data - buf */
void *buf; /* base address of buffer */
@@ -33,7 +33,7 @@ typedef struct iocur {
xfs_ino_t dirino; /* current directory inode number */
xfs_ino_t ino; /* current inode number */
int len; /* length of "data", bytes */
- __uint16_t mode; /* current inode's mode */
+ uint16_t mode; /* current inode's mode */
xfs_off_t off; /* fs offset of "data" in bytes */
const struct typ *typ; /* type of "data" */
bbmap_t *bbmap; /* map daddr if fragmented */
@@ -57,9 +57,9 @@ extern void off_cur(int off, int len);
extern void pop_cur(void);
extern void print_iocur(char *tag, iocur_t *ioc);
extern void push_cur(void);
-extern int read_buf(__int64_t daddr, int count, void *bufp);
+extern int read_buf(int64_t daddr, int count, void *bufp);
extern void write_cur(void);
-extern void set_cur(const struct typ *t, __int64_t d, int c, int ring_add,
+extern void set_cur(const struct typ *t, int64_t d, int c, int ring_add,
bbmap_t *bbmap);
extern void ring_add(void);
extern void set_iocur_type(const struct typ *t);
diff --git a/db/metadump.c b/db/metadump.c
index 8455fdd..0bb6e3d 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;
@@ -1093,7 +1093,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);
@@ -1159,7 +1159,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;
@@ -1196,7 +1196,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);
@@ -1468,7 +1468,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;
@@ -2106,7 +2106,7 @@ done:
return success;
}
-static __uint32_t inodes_copied = 0;
+static uint32_t inodes_copied = 0;
static int
copy_inode_chunk(
diff --git a/db/sb.c b/db/sb.c
index 79a3c1d..e870aa6 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;
@@ -708,8 +708,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 424fbce..f32aced 100644
--- a/fsr/xfs_fsr.c
+++ b/fsr/xfs_fsr.c
@@ -57,7 +57,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 dd6132f..8a85878 100644
--- a/include/darwin.h
+++ b/include/darwin.h
@@ -125,15 +125,6 @@ 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 off64_t off_t
typedef off_t xfs_off_t;
diff --git a/include/freebsd.h b/include/freebsd.h
index 65bd60a..e3e995f 100644
--- a/include/freebsd.h
+++ b/include/freebsd.h
@@ -50,9 +50,9 @@
typedef off_t xfs_off_t;
typedef off_t off64_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 unsigned char __u8;
typedef signed char __s8;
diff --git a/include/gnukfreebsd.h b/include/gnukfreebsd.h
index 64167b2..b2d2cf3 100644
--- a/include/gnukfreebsd.h
+++ b/include/gnukfreebsd.h
@@ -39,9 +39,9 @@
#define EFSBADCRC 991 /* 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 unsigned char __u8;
typedef signed char __s8;
diff --git a/include/irix.h b/include/irix.h
index 293f869..d6aa5e1 100644
--- a/include/irix.h
+++ b/include/irix.h
@@ -39,14 +39,10 @@
#include <sys/fs/xfs_itable.h>
#include <mntent.h>
-#define __int8_t char
-#define __int16_t short
-#define __uint8_t unsigned char
-#define __uint16_t unsigned short
typedef off64_t xfs_off_t;
-typedef __int64_t xfs_ino_t;
-typedef __int32_t xfs_dev_t;
-typedef __int64_t xfs_daddr_t;
+typedef int64_t xfs_ino_t;
+typedef int32_t xfs_dev_t;
+typedef int64_t xfs_daddr_t;
typedef unsigned char __u8;
typedef signed char __s8;
@@ -63,17 +59,17 @@ typedef signed long long int __s64;
#define EFSBADCRC 991 /* Bad CRC detected */
typedef struct xfs_error_injection {
- __int32_t fd;
- __int32_t errtag;
+ int32_t fd;
+ int32_t errtag;
} xfs_error_injection_t;
/* --- xfs_fsop_*req - request data structures --- */
typedef struct xfs_fsop_bulkreq {
ino64_t *lastip;
- __int32_t icount;
+ int32_t icount;
xfs_bstat_t *ubuffer;
- __int32_t *ocount;
+ int32_t *ocount;
} xfs_fsop_bulkreq_t;
typedef struct xfs_fsop_handlereq {
@@ -302,13 +298,13 @@ static __inline__ void platform_getoptreset(void)
static __inline__ int platform_uuid_compare(uuid_t *uu1, uuid_t *uu2)
{
- __uint32_t status;
+ uint32_t status;
return uuid_compare(uu1, uu2, &status);
}
static __inline__ void platform_uuid_unparse(uuid_t *uu, char *buffer)
{
- __uint32_t status;
+ uint32_t status;
char *s;
uuid_to_string(uu, &s, &status);
if (status == uuid_s_ok)
@@ -319,7 +315,7 @@ static __inline__ void platform_uuid_unparse(uuid_t *uu, char *buffer)
static __inline__ int platform_uuid_parse(char *buffer, uuid_t *uu)
{
- __uint32_t status;
+ uint32_t status;
uuid_from_string(buffer, uu, &status);
return (status == uuid_s_ok);
}
@@ -332,13 +328,13 @@ static __inline__ int platform_uuid_is_null(uuid_t *uu)
static __inline__ void platform_uuid_generate(uuid_t *uu)
{
- __uint32_t status;
+ uint32_t status;
uuid_create(uu, &status);
}
static __inline__ void platform_uuid_clear(uuid_t *uu)
{
- __uint32_t status;
+ uint32_t status;
uuid_create_nil(uu, &status);
}
diff --git a/include/linux.h b/include/linux.h
index 674717c..827dbe1 100644
--- a/include/linux.h
+++ b/include/linux.h
@@ -124,7 +124,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;
@@ -142,9 +142,9 @@ platform_discard_blocks(int fd, uint64_t start, uint64_t len)
#define EFSBADCRC EBADMSG /* Bad CRC detected */
typedef loff_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;
/**
* Abstraction of mountpoints.
diff --git a/include/xfs_arch.h b/include/xfs_arch.h
index 87650f1..c44d993 100644
--- a/include/xfs_arch.h
+++ b/include/xfs_arch.h
@@ -240,39 +240,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 71c0fb4..708f8c6 100644
--- a/include/xfs_inode.h
+++ b/include/xfs_inode.h
@@ -77,8 +77,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);
}
typedef struct cred {
diff --git a/include/xfs_log_recover.h b/include/xfs_log_recover.h
index 2fea63d..69f276c 100644
--- a/include/xfs_log_recover.h
+++ b/include/xfs_log_recover.h
@@ -26,7 +26,7 @@
#define XLOG_RHASH_SIZE 16
#define XLOG_RHASH_SHIFT 2
#define XLOG_RHASH(tid) \
- ((((__uint32_t)tid)>>XLOG_RHASH_SHIFT) & (XLOG_RHASH_SIZE-1))
+ ((((uint32_t)tid)>>XLOG_RHASH_SHIFT) & (XLOG_RHASH_SIZE-1))
#define XLOG_MAX_REGIONS_IN_ITEM (XFS_MAX_BLOCKSIZE / XFS_BLF_CHUNK / 2 + 1)
diff --git a/include/xfs_metadump.h b/include/xfs_metadump.h
index f4be51b..3ce5138 100644
--- a/include/xfs_metadump.h
+++ b/include/xfs_metadump.h
@@ -24,8 +24,8 @@
typedef struct xfs_metablock {
__be32 mb_magic;
__be16 mb_count;
- __uint8_t mb_blocklog;
- __uint8_t mb_reserved;
+ uint8_t mb_blocklog;
+ uint8_t mb_reserved;
/* followed by an array of xfs_daddr_t */
} xfs_metablock_t;
diff --git a/include/xfs_mount.h b/include/xfs_mount.h
index 14b05a6..e0d5f48 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 */
@@ -78,7 +78,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 */
@@ -118,12 +118,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 */
diff --git a/libhandle/handle.c b/libhandle/handle.c
index 236ed22..00127b3 100644
--- a/libhandle/handle.c
+++ b/libhandle/handle.c
@@ -232,7 +232,7 @@ obj_to_handle(
{
char hbuf [MAXHANSIZ];
int ret;
- __uint32_t handlen;
+ uint32_t handlen;
xfs_fsop_handlereq_t hreq;
if (opcode == XFS_IOC_FD_TO_HANDLE) {
diff --git a/libhandle/jdm.c b/libhandle/jdm.c
index e52f5d8..821061b 100644
--- a/libhandle/jdm.c
+++ b/libhandle/jdm.c
@@ -36,7 +36,7 @@ typedef struct filehandle {
fshandle_t fh_fshandle; /* handle of fs containing this inode */
int16_t fh_sz_following; /* bytes in handle after this member */
char fh_pad[FILEHANDLE_SZ_PAD]; /* padding, must be zeroed */
- __uint32_t fh_gen; /* generation count */
+ uint32_t fh_gen; /* generation count */
xfs_ino_t fh_ino; /* 64 bit ino */
} filehandle_t;
diff --git a/libxfs/darwin.c b/libxfs/darwin.c
index 017e190..1bd6c8a 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 stat64 st;
if (fstat64(fd, &st) < 0) {
diff --git a/libxfs/freebsd.c b/libxfs/freebsd.c
index 6c9f089..96f2c67 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 8d747e8..4e73e13 100644
--- a/libxfs/init.c
+++ b/libxfs/init.c
@@ -529,7 +529,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 65aaa7e..f4e7f47 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 stat64 *s, int verbose)
diff --git a/libxfs/libxfs_priv.h b/libxfs/libxfs_priv.h
index 0f4d3e5..ffd6bf7 100644
--- a/libxfs/libxfs_priv.h
+++ b/libxfs/libxfs_priv.h
@@ -307,8 +307,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 f6ea1b2..c532d65 100644
--- a/libxfs/linux.c
+++ b/libxfs/linux.c
@@ -133,7 +133,7 @@ void
platform_findsizes(char *path, int fd, long long *sz, int *bsz)
{
struct stat64 st;
- __uint64_t size;
+ uint64_t size;
int error;
if (fstat64(fd, &st) < 0) {
diff --git a/libxfs/logitem.c b/libxfs/logitem.c
index 7e93f60..466b442 100644
--- a/libxfs/logitem.c
+++ b/libxfs/logitem.c
@@ -121,7 +121,7 @@ xfs_buf_item_init(
bip->bli_item.li_mountp = mp;
bip->bli_buf = bp;
bip->bli_format.blf_type = XFS_LI_BUF;
- bip->bli_format.blf_blkno = (__int64_t)XFS_BUF_ADDR(bp);
+ bip->bli_format.blf_blkno = (int64_t)XFS_BUF_ADDR(bp);
bip->bli_format.blf_len = (unsigned short)BTOBB(XFS_BUF_COUNT(bp));
XFS_BUF_SET_FSPRIVATE(bp, bip);
}
diff --git a/libxfs/radix-tree.c b/libxfs/radix-tree.c
index eef9c36..3f0257f 100644
--- a/libxfs/radix-tree.c
+++ b/libxfs/radix-tree.c
@@ -66,21 +66,21 @@ static unsigned long height_to_maxindex[RADIX_TREE_MAX_PATH];
static inline void tag_set(struct radix_tree_node *node, unsigned int tag,
int offset)
{
- *((__uint32_t *)node->tags[tag] + (offset >> 5)) |= (1 << (offset & 31));
+ *((uint32_t *)node->tags[tag] + (offset >> 5)) |= (1 << (offset & 31));
}
static inline void tag_clear(struct radix_tree_node *node, unsigned int tag,
int offset)
{
- __uint32_t *p = (__uint32_t*)node->tags[tag] + (offset >> 5);
- __uint32_t m = 1 << (offset & 31);
+ uint32_t *p = (uint32_t*)node->tags[tag] + (offset >> 5);
+ uint32_t m = 1 << (offset & 31);
*p &= ~m;
}
static inline int tag_get(struct radix_tree_node *node, unsigned int tag,
int offset)
{
- return 1 & (((const __uint32_t *)node->tags[tag])[offset >> 5] >> (offset & 31));
+ return 1 & (((const uint32_t *)node->tags[tag])[offset >> 5] >> (offset & 31));
}
/*
diff --git a/libxfs/rdwr.c b/libxfs/rdwr.c
index 7a04985..5f0ac24 100644
--- a/libxfs/rdwr.c
+++ b/libxfs/rdwr.c
@@ -116,9 +116,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 90031fd..8d7baa0 100644
--- a/libxfs/util.c
+++ b/libxfs/util.c
@@ -160,16 +160,16 @@ libxfs_trans_ichgtime(
tv.tv_sec = stv.tv_sec;
tv.tv_nsec = stv.tv_usec * 1000;
if (flags & XFS_ICHGTIME_MOD) {
- ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
- ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
+ ip->i_d.di_mtime.t_sec = (int32_t)tv.tv_sec;
+ ip->i_d.di_mtime.t_nsec = (int32_t)tv.tv_nsec;
}
if (flags & XFS_ICHGTIME_CHG) {
- ip->i_d.di_ctime.t_sec = (__int32_t)tv.tv_sec;
- ip->i_d.di_ctime.t_nsec = (__int32_t)tv.tv_nsec;
+ ip->i_d.di_ctime.t_sec = (int32_t)tv.tv_sec;
+ ip->i_d.di_ctime.t_nsec = (int32_t)tv.tv_nsec;
}
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;
}
}
@@ -219,7 +219,7 @@ libxfs_ialloc(
return error;
ASSERT(ip != NULL);
- ip->i_d.di_mode = (__uint16_t)mode;
+ ip->i_d.di_mode = (uint16_t)mode;
ip->i_d.di_onlink = 0;
ip->i_d.di_nlink = nlink;
ASSERT(ip->i_d.di_nlink == nlink);
diff --git a/libxfs/xfs_alloc_btree.c b/libxfs/xfs_alloc_btree.c
index 6f13572..e3f3338 100644
--- a/libxfs/xfs_alloc_btree.c
+++ b/libxfs/xfs_alloc_btree.c
@@ -246,25 +246,25 @@ xfs_allocbt_init_ptr_from_cur(
ptr->s = agf->agf_roots[cur->bc_btnum];
}
-STATIC __int64_t
+STATIC int64_t
xfs_allocbt_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;
if (cur->bc_btnum == XFS_BTNUM_BNO) {
- return (__int64_t)be32_to_cpu(kp->ar_startblock) -
+ return (int64_t)be32_to_cpu(kp->ar_startblock) -
rec->ar_startblock;
}
- 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 bool
diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c
index 95383e3..ce55a79 100644
--- a/libxfs/xfs_attr_remote.c
+++ b/libxfs/xfs_attr_remote.c
@@ -247,7 +247,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;
@@ -295,7 +295,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;
@@ -349,7 +349,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_ta *dst = args->value;
int valuelen;
int nmap;
int error;
@@ -415,7 +415,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 919756e..085ff84 100644
--- a/libxfs/xfs_attr_sf.h
+++ b/libxfs/xfs_attr_sf.h
@@ -34,10 +34,10 @@ typedef struct xfs_attr_shortform {
__u8 count; /* count of active entries */
} 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;
typedef struct xfs_attr_sf_hdr xfs_attr_sf_hdr_t;
@@ -47,10 +47,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;
@@ -58,7 +58,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 2ef1836..fb5edca 100644
--- a/libxfs/xfs_bmap_btree.c
+++ b/libxfs/xfs_bmap_btree.c
@@ -95,8 +95,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;
@@ -624,12 +624,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 658f27e..1c700c0 100644
--- a/libxfs/xfs_btree.c
+++ b/libxfs/xfs_btree.c
@@ -38,7 +38,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, XFS_BMAP_MAGIC, XFS_IBT_MAGIC,
XFS_FIBT_MAGIC },
{ XFS_ABTB_CRC_MAGIC, XFS_ABTC_CRC_MAGIC,
@@ -673,14 +673,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);
/*
@@ -1711,7 +1711,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 */
@@ -3992,7 +3992,7 @@ static int
xfs_btree_block_change_owner(
struct xfs_btree_cur *cur,
int level,
- __uint64_t new_owner,
+ uint64_t new_owner,
struct list_head *buffer_list)
{
struct xfs_btree_block *block;
@@ -4039,7 +4039,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)
{
union xfs_btree_ptr lptr;
diff --git a/libxfs/xfs_btree.h b/libxfs/xfs_btree.h
index 48cb251..41376bb 100644
--- a/libxfs/xfs_btree.h
+++ b/libxfs/xfs_btree.h
@@ -159,7 +159,7 @@ struct xfs_btree_ops {
union xfs_btree_ptr *ptr);
/* 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);
const struct xfs_buf_ops *buf_ops;
@@ -202,11 +202,11 @@ typedef struct xfs_btree_cur
} 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 */
union {
struct { /* needed for BNO, CNT, INO */
@@ -315,7 +315,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 */
@@ -393,7 +393,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);
/*
@@ -419,7 +419,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 fad1676..3c2bc92 100644
--- a/libxfs/xfs_cksum.h
+++ b/libxfs/xfs_cksum.h
@@ -1,18 +1,18 @@
#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
* inside it. The offset of the 32bit crc fields is passed as the
* cksum_offset parameter.
*/
-static inline __uint32_t
+static inline uint32_t
xfs_start_cksum(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);
@@ -33,7 +33,7 @@ xfs_start_cksum(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);
}
@@ -44,7 +44,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(buffer, length, cksum_offset);
+ uint32_t crc = xfs_start_cksum(buffer, length, cksum_offset);
*(__le32 *)(buffer + cksum_offset) = xfs_end_cksum(crc);
}
@@ -55,7 +55,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(buffer, length, cksum_offset);
+ uint32_t crc = xfs_start_cksum(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 bf5fe21..cdddca1 100644
--- a/libxfs/xfs_da_btree.c
+++ b/libxfs/xfs_da_btree.c
@@ -1943,7 +1943,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 6e153e3..cefbdf6 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 @@ xfs_daddr_t 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 e4c37f9..770d1f6 100644
--- a/libxfs/xfs_da_format.c
+++ b/libxfs/xfs_da_format.c
@@ -50,7 +50,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 *
@@ -78,7 +78,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)
{
@@ -88,16 +88,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)
@@ -108,7 +108,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);
@@ -230,7 +230,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
@@ -247,7 +247,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)
{
@@ -257,16 +257,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;
@@ -276,7 +276,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 b14bbd6..6b0f629 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,7 +187,7 @@ 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 */
@@ -195,12 +195,12 @@ typedef uint xfs_dir2_data_aoff_t; /* argument form */
* Normalized offset (in a data block) of the entry, really xfs_dir2_data_off_t.
* Only need 16 bits, this is the byte offset into the single block form.
*/
-typedef struct { __uint8_t i[2]; } __arch_pack xfs_dir2_sf_off_t;
+typedef struct { uint8_t i[2]; } __arch_pack xfs_dir2_sf_off_t;
/*
* 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)
@@ -212,19 +212,19 @@ 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;
/*
* Inode number stored as 8 8-bit values.
*/
-typedef struct { __uint8_t i[8]; } xfs_dir2_ino8_t;
+typedef struct { uint8_t i[8]; } xfs_dir2_ino8_t;
/*
* Inode number stored as 4 8-bit values.
* Works a lot of the time, when all the inode numbers in a directory
* fit in 32 bits.
*/
-typedef struct { __uint8_t i[4]; } xfs_dir2_ino4_t;
+typedef struct { uint8_t i[4]; } xfs_dir2_ino4_t;
typedef union {
xfs_dir2_ino8_t i8;
@@ -244,8 +244,8 @@ typedef union {
* 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 count; /* count of entries */
+ uint8_t i8count; /* count of 8-byte inode #s */
xfs_dir2_inou_t parent; /* parent dir inode number */
} __arch_pack xfs_dir2_sf_hdr_t;
@@ -466,11 +466,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;
};
/*
@@ -557,10 +557,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;
};
@@ -727,22 +727,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 0129e37..69af9f7 100644
--- a/libxfs/xfs_dir2.h
+++ b/libxfs/xfs_dir2.h
@@ -45,9 +45,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,
@@ -58,9 +58,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 d04547f..6cdb465 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_format.h b/libxfs/xfs_format.h
index a35009a..4ebd0da 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;
}
@@ -461,7 +461,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;
}
@@ -479,7 +479,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;
}
@@ -489,7 +489,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;
}
@@ -579,8 +579,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)
/*
@@ -1032,7 +1032,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
@@ -1229,16 +1229,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)
{
@@ -1272,9 +1272,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;
@@ -1345,11 +1345,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 d8b733a..8fbbdff 100644
--- a/libxfs/xfs_fs.h
+++ b/libxfs/xfs_fs.h
@@ -319,10 +319,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;
}
/*
@@ -472,10 +472,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 */
@@ -565,7 +565,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 64c3acf..ed228fb 100644
--- a/libxfs/xfs_ialloc.c
+++ b/libxfs/xfs_ialloc.c
@@ -133,9 +133,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 52939c3..31b5923 100644
--- a/libxfs/xfs_ialloc_btree.c
+++ b/libxfs/xfs_ialloc_btree.c
@@ -205,12 +205,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 324715e..8bcb52a 100644
--- a/libxfs/xfs_inode_buf.c
+++ b/libxfs/xfs_inode_buf.c
@@ -325,7 +325,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_log_format.h b/libxfs/xfs_log_format.h
index db8ceeb..ccc0fdb 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
@@ -205,7 +205,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;
@@ -242,52 +242,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;
/*
@@ -355,8 +355,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;
/*
@@ -364,18 +364,18 @@ typedef struct xfs_ictimestamp {
* except for the endianness annotations.
*/
typedef struct xfs_icdinode {
- __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 */
- __uint16_t di_onlink; /* old number of links to file */
- __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 */
+ uint16_t di_onlink; /* old number of links to file */
+ 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 */
@@ -384,22 +384,22 @@ typedef struct xfs_icdinode {
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 */
- __uint8_t di_pad2[16]; /* more padding for future expansion */
+ uint64_t di_flags2; /* more random flags */
+ uint8_t di_pad2[16]; /* more padding for future expansion */
/* fields only written to during inode creation */
xfs_ictimestamp_t di_crtime; /* time created */
@@ -458,7 +458,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;
@@ -506,7 +506,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;
@@ -527,14 +527,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;
/*
@@ -543,26 +543,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;
@@ -572,26 +572,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;
@@ -602,12 +602,12 @@ typedef struct xfs_efd_log_format_64 {
* 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;
/*
@@ -666,8 +666,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 1b0a083..b6f63e2 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_rtbitmap.c b/libxfs/xfs_rtbitmap.c
index 5648ea5..09237cb 100644
--- a/libxfs/xfs_rtbitmap.c
+++ b/libxfs/xfs_rtbitmap.c
@@ -978,7 +978,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 *)&mp->m_rbmip->i_d.di_atime = 0;
+ *(uint64_t *)&mp->m_rbmip->i_d.di_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 78ad889..28cef20 100644
--- a/libxfs/xfs_sb.c
+++ b/libxfs/xfs_sb.c
@@ -417,7 +417,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)) {
@@ -712,7 +712,7 @@ xfs_sb_mount_common(
mp->m_bmap_dmnr[1] = mp->m_bmap_dmxr[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 f0d145a..27b0ed6 100644
--- a/libxfs/xfs_types.h
+++ b/libxfs/xfs_types.h
@@ -18,34 +18,34 @@
#ifndef __XFS_TYPES_H__
#define __XFS_TYPES_H__
-typedef __uint32_t prid_t; /* project ID */
+typedef uint32_t prid_t; /* project ID */
-typedef __uint32_t xfs_agblock_t; /* blockno in alloc. group */
-typedef __uint32_t xfs_agino_t; /* inode # within allocation grp */
-typedef __uint32_t xfs_extlen_t; /* extent length in blocks */
-typedef __uint32_t xfs_agnumber_t; /* allocation group number */
-typedef __int32_t xfs_extnum_t; /* # of extents in a file */
-typedef __int16_t xfs_aextnum_t; /* # extents in an attribute fork */
-typedef __int64_t xfs_fsize_t; /* bytes in a file */
-typedef __uint64_t xfs_ufsize_t; /* unsigned bytes in a file */
+typedef uint32_t xfs_agblock_t; /* blockno in alloc. group */
+typedef uint32_t xfs_agino_t; /* inode # within allocation grp */
+typedef uint32_t xfs_extlen_t; /* extent length in blocks */
+typedef uint32_t xfs_agnumber_t; /* allocation group number */
+typedef int32_t xfs_extnum_t; /* # of extents in a file */
+typedef int16_t xfs_aextnum_t; /* # extents in an attribute fork */
+typedef int64_t xfs_fsize_t; /* bytes in a file */
+typedef uint64_t xfs_ufsize_t; /* unsigned bytes in a file */
-typedef __int32_t xfs_suminfo_t; /* type of bitmap summary info */
-typedef __int32_t xfs_rtword_t; /* word type for bitmap manipulations */
+typedef int32_t xfs_suminfo_t; /* type of bitmap summary info */
+typedef int32_t xfs_rtword_t; /* word type for bitmap manipulations */
-typedef __int64_t xfs_lsn_t; /* log sequence number */
-typedef __int32_t xfs_tid_t; /* transaction identifier */
+typedef int64_t xfs_lsn_t; /* log sequence number */
+typedef int32_t xfs_tid_t; /* transaction identifier */
-typedef __uint32_t xfs_dablk_t; /* dir/attr block number (in file) */
-typedef __uint32_t xfs_dahash_t; /* dir/attr hash value */
+typedef uint32_t xfs_dablk_t; /* dir/attr block number (in file) */
+typedef uint32_t xfs_dahash_t; /* dir/attr hash value */
-typedef __uint64_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */
-typedef __uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */
-typedef __uint64_t xfs_rtblock_t; /* extent (block) in realtime area */
-typedef __uint64_t xfs_fileoff_t; /* block number in a file */
-typedef __uint64_t xfs_filblks_t; /* number of blocks in a file */
+typedef uint64_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */
+typedef uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */
+typedef uint64_t xfs_rtblock_t; /* extent (block) in realtime area */
+typedef uint64_t xfs_fileoff_t; /* block number in a file */
+typedef uint64_t xfs_filblks_t; /* number of blocks in a file */
-typedef __int64_t xfs_srtblock_t; /* signed version of xfs_rtblock_t */
-typedef __int64_t xfs_sfiloff_t; /* signed block number in a file */
+typedef int64_t xfs_srtblock_t; /* signed version of xfs_rtblock_t */
+typedef int64_t xfs_sfiloff_t; /* signed block number in a file */
/*
* Null values for the types.
@@ -125,7 +125,7 @@ struct xfs_name {
* uid_t and gid_t are hard-coded to 32 bits in the inode.
* Hence, an 'id' in a dquot is 32 bits..
*/
-typedef __uint32_t xfs_dqid_t;
+typedef uint32_t xfs_dqid_t;
/*
* Constants for bit manipulations.
diff --git a/logprint/log_misc.c b/logprint/log_misc.c
index 7378fe1..52fc504 100644
--- a/logprint/log_misc.c
+++ b/logprint/log_misc.c
@@ -212,12 +212,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
@@ -247,7 +247,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 ebc5e54..07614e0 100644
--- a/mdrestore/xfs_mdrestore.c
+++ b/mdrestore/xfs_mdrestore.c
@@ -65,7 +65,7 @@ perform_restore(
int mb_count;
xfs_metablock_t tmb;
xfs_sb_t sb;
- __int64_t bytes_read;
+ int64_t bytes_read;
/*
* read in first blocks (superblock 0), set "inprogress" flag for it,
diff --git a/mkfs/proto.c b/mkfs/proto.c
index cb34b28..f68d691 100644
--- a/mkfs/proto.c
+++ b/mkfs/proto.c
@@ -655,7 +655,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 *)&rbmip->i_d.di_atime = 0;
+ *(uint64_t *)&rbmip->i_d.di_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 700d12c..42dd69b 100644
--- a/mkfs/xfs_mkfs.c
+++ b/mkfs/xfs_mkfs.c
@@ -188,9 +188,9 @@ char *mopts[] = {
NULL
};
-#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
@@ -540,7 +540,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
@@ -572,7 +572,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,
@@ -596,7 +596,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,
@@ -621,7 +621,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
@@ -644,12 +644,12 @@ calc_default_imaxpct(
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;
/*
@@ -714,9 +714,9 @@ done:
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,
@@ -792,7 +792,7 @@ zero_old_xfs_structures(
{
void *buf;
xfs_sb_t sb;
- __uint32_t bsize;
+ uint32_t bsize;
int i;
xfs_off_t off;
int tmp;
@@ -843,8 +843,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;
@@ -864,7 +864,7 @@ done:
}
static void
-discard_blocks(dev_t dev, __uint64_t nsectors)
+discard_blocks(dev_t dev, uint64_t nsectors)
{
int fd;
@@ -882,11 +882,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;
int attrversion;
int projid16bit;
@@ -971,10 +971,10 @@ main(
xfs_sb_t *sbp;
int sectorlog;
unsigned int sectorsize;
- __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;
@@ -1086,9 +1086,9 @@ main(
reqval('d', dopts, D_AGCOUNT);
if (daflag)
respec('d', dopts, D_AGCOUNT);
- agcount = (__uint64_t)
+ agcount = (uint64_t)
strtoul(value, NULL, 10);
- if ((__int64_t)agcount <= 0)
+ if ((int64_t)agcount <= 0)
illegal(value, "d agcount");
daflag = 1;
break;
@@ -1915,7 +1915,7 @@ _("warning: sparse inodes not supported without CRC support, disabled.\n"));
usage();
}
if (dsize) {
- __uint64_t dbytes;
+ uint64_t dbytes;
dbytes = cvtnum(blocksize, sectorsize, dsize);
if (dbytes % XFS_MIN_BLOCKSIZE) {
@@ -1952,7 +1952,7 @@ _("warning: sparse inodes not supported without CRC support, disabled.\n"));
usage();
}
if (logsize) {
- __uint64_t logbytes;
+ uint64_t logbytes;
logbytes = cvtnum(blocksize, sectorsize, logsize);
if (logbytes % XFS_MIN_BLOCKSIZE) {
@@ -1974,7 +1974,7 @@ _("warning: sparse inodes not supported without CRC support, disabled.\n"));
usage();
}
if (rtsize) {
- __uint64_t rtbytes;
+ uint64_t rtbytes;
rtbytes = cvtnum(blocksize, sectorsize, rtsize);
if (rtbytes % XFS_MIN_BLOCKSIZE) {
@@ -1994,7 +1994,7 @@ _("warning: sparse inodes not supported without CRC support, disabled.\n"));
* If specified, check rt extent size against its constraints.
*/
if (rtextsize) {
- __uint64_t rtextbytes;
+ uint64_t rtextbytes;
rtextbytes = cvtnum(blocksize, sectorsize, rtextsize);
if (rtextbytes % blocksize) {
@@ -2022,8 +2022,8 @@ _("warning: sparse inodes not supported without CRC support, disabled.\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;
@@ -2101,10 +2101,10 @@ _("warning: sparse inodes not supported without CRC support, disabled.\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);
if (!force_overwrite) {
if (check_overwrite(dfile) ||
@@ -2473,9 +2473,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;
@@ -2603,14 +2603,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;
@@ -2638,8 +2638,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 c55fa1a..f970e66 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;
@@ -379,8 +379,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) {
@@ -531,7 +531,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 dcbe8ce..30ce38b 100644
--- a/quota/free.c
+++ b/quota/free.c
@@ -48,20 +48,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) {
@@ -115,15 +115,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;
@@ -209,9 +209,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 9116e48..19d2253 100644
--- a/quota/quot.c
+++ b/quota/quot.c
@@ -25,17 +25,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
@@ -83,8 +83,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;
@@ -202,7 +202,7 @@ qcompare(
return 0;
}
-typedef char *(*idtoname_t)(__uint32_t);
+typedef char *(*idtoname_t)(uint32_t);
static void
quot_report_mount_any_type(
@@ -290,7 +290,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 f6b24c3..d02e54e 100644
--- a/quota/quota.c
+++ b/quota/quota.c
@@ -51,7 +51,7 @@ quota_help(void)
static int
quota_mount(
FILE *fp,
- __uint32_t id,
+ uint32_t id,
char *name,
uint form,
uint type,
@@ -180,7 +180,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 416f335..eb7a4fc 100644
--- a/quota/quota.h
+++ b/quota/quota.h
@@ -51,9 +51,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);
@@ -78,7 +78,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 c77b24f..d03f88d 100644
--- a/quota/report.c
+++ b/quota/report.c
@@ -289,7 +289,7 @@ report_header(
static int
report_mount(
FILE *fp,
- __uint32_t id,
+ uint32_t id,
char *name,
uint form,
uint type,
diff --git a/quota/state.c b/quota/state.c
index 8186762..82dd26d 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 179aafd..f51f375 100644
--- a/quota/util.c
+++ b/quota/util.c
@@ -83,8 +83,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;
@@ -96,23 +96,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)
{
@@ -135,17 +135,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)
{
@@ -172,8 +172,8 @@ num_to_string(
char *
pct_to_string(
- __uint64_t portion,
- __uint64_t whole,
+ uint64_t portion,
+ uint64_t whole,
char *buf,
uint size)
{
@@ -226,7 +226,7 @@ type_to_string(
#define IDMASK (NID-1)
typedef struct {
- __uint32_t id;
+ uint32_t id;
char name[NMAX+1];
} idcache_t;
@@ -239,7 +239,7 @@ static int pentriesleft = NID;
static idcache_t *
getnextpwent(
- __uint32_t id,
+ uint32_t id,
int byid)
{
struct passwd *pw;
@@ -255,7 +255,7 @@ getnextpwent(
static idcache_t *
getnextgrent(
- __uint32_t id,
+ uint32_t id,
int byid)
{
struct group *gr;
@@ -270,7 +270,7 @@ getnextgrent(
static idcache_t *
getnextprent(
- __uint32_t id,
+ uint32_t id,
int byid)
{
fs_project_t *pr;
@@ -285,7 +285,7 @@ getnextprent(
char *
uid_to_name(
- __uint32_t id)
+ uint32_t id)
{
idcache_t *ncp, *idp;
@@ -322,7 +322,7 @@ uid_to_name(
char *
gid_to_name(
- __uint32_t id)
+ uint32_t id)
{
idcache_t *ncp, *idp;
@@ -359,7 +359,7 @@ gid_to_name(
char *
prid_to_name(
- __uint32_t id)
+ uint32_t id)
{
idcache_t *ncp, *idp;
diff --git a/repair/README b/repair/README
index 7f168e6..4692463 100644
--- a/repair/README
+++ b/repair/README
@@ -189,7 +189,7 @@ D - 0) look at usage of XFS_MAKE_IPTR(). It does the right
D - 0) look at references to XFS_INODES_PER_CHUNK. change the
- ones that really mean sizeof(__uint64_t)*NBBY to
+ ones that really mean sizeof(uint64_t)*NBBY to
something else (like that only defined as a constant
INOS_PER_IREC. this isn't as important since
XFS_INODES_PER_CHUNK will never chang
--git a/repair/agheader.h b/repair/agheader.h
index 6b2974c..e9075d1 100644
--- a/repair/agheader.h
+++ b/repair/agheader.h
@@ -20,7 +20,7 @@ typedef struct fs_geometry {
/*
* these types should match the superblock types
*/
- __uint32_t sb_blocksize; /* blocksize (bytes) */
+ uint32_t sb_blocksize; /* blocksize (bytes) */
xfs_rfsblock_t sb_dblocks; /* # data blocks */
xfs_rfsblock_t sb_rblocks; /* # realtime blocks */
xfs_rtblock_t sb_rextents; /* # realtime extents */
@@ -30,9 +30,9 @@ typedef struct fs_geometry {
xfs_agnumber_t sb_agcount; /* # of ags */
xfs_extlen_t sb_rbmblocks; /* # of rt bitmap blocks */
xfs_extlen_t sb_logblocks; /* # of log blocks */
- __uint16_t sb_sectsize; /* volume sector size (bytes) */
- __uint16_t sb_inodesize; /* inode size (bytes) */
- __uint8_t sb_imax_pct; /* max % of fs for inode space */
+ uint16_t sb_sectsize; /* volume sector size (bytes) */
+ uint16_t sb_inodesize; /* inode size (bytes) */
+ uint8_t sb_imax_pct; /* max % of fs for inode space */
/*
* these don't have to match the superblock types but are placed
@@ -49,10 +49,10 @@ typedef struct fs_geometry {
/*
* fields after this point have to be checked manually in compare_sb()
*/
- __uint8_t sb_shared_vn; /* shared version number */
+ uint8_t sb_shared_vn; /* shared version number */
xfs_extlen_t sb_inoalignmt; /* inode chunk alignment, fsblocks */
- __uint32_t sb_unit; /* stripe or raid unit */
- __uint32_t sb_width; /* stripe or width unit */
+ uint32_t sb_unit; /* stripe or raid unit */
+ uint32_t sb_width; /* stripe or width unit */
/*
* these don't have to match, they track superblock properties
diff --git a/repair/attr_repair.h b/repair/attr_repair.h
index 7010e4f..02e056f 100644
--- a/repair/attr_repair.h
+++ b/repair/attr_repair.h
@@ -32,10 +32,10 @@
#define ACL_WRITE 02
#define ACL_EXECUTE 01
-typedef __uint16_t xfs_acl_perm_t;
-typedef __int32_t xfs_acl_type_t;
-typedef __int32_t xfs_acl_tag_t;
-typedef __int32_t xfs_acl_id_t;
+typedef uint16_t xfs_acl_perm_t;
+typedef int32_t xfs_acl_type_t;
+typedef int32_t xfs_acl_tag_t;
+typedef int32_t xfs_acl_id_t;
/*
* "icacl" = in-core ACL. There is no equivalent in the XFS kernel code,
@@ -50,7 +50,7 @@ struct xfs_icacl_entry {
};
struct xfs_icacl {
- __int32_t acl_cnt;
+ int32_t acl_cnt;
struct xfs_icacl_entry acl_entry[0];
};
@@ -59,14 +59,14 @@ struct xfs_icacl {
*/
#define XFS_MAC_MAX_SETS 250
typedef struct xfs_mac_label {
- __uint8_t ml_msen_type; /* MSEN label type */
- __uint8_t ml_mint_type; /* MINT label type */
- __uint8_t ml_level; /* Hierarchical level */
- __uint8_t ml_grade; /* Hierarchical grade */
- __uint16_t ml_catcount; /* Category count */
- __uint16_t ml_divcount; /* Division count */
+ uint8_t ml_msen_type; /* MSEN label type */
+ uint8_t ml_mint_type; /* MINT label type */
+ uint8_t ml_level; /* Hierarchical level */
+ uint8_t ml_grade; /* Hierarchical grade */
+ uint16_t ml_catcount; /* Category count */
+ uint16_t ml_divcount; /* Division count */
/* Category set, then Division set */
- __uint16_t ml_list[XFS_MAC_MAX_SETS];
+ uint16_t ml_list[XFS_MAC_MAX_SETS];
} xfs_mac_label_t;
/* MSEN label type names. Choose an upper case ASCII character. */
@@ -93,7 +93,7 @@ typedef struct xfs_mac_label {
/*
* Capabilities (IRIX)
*/
-typedef __uint64_t xfs_cap_value_t;
+typedef uint64_t xfs_cap_value_t;
typedef struct xfs_cap_set {
xfs_cap_value_t cap_effective; /* use in capability checks */
diff --git a/repair/avl64.c b/repair/avl64.c
index 51cd624..8f4a121 100644
--- a/repair/avl64.c
+++ b/repair/avl64.c
@@ -70,8 +70,8 @@ avl64_checktree(
avl64node_t *root)
{
avl64node_t *nlast, *nnext, *np;
- __uint64_t offset = 0;
- __uint64_t end;
+ uint64_t offset = 0;
+ uint64_t end;
nlast = nnext = root;
@@ -583,8 +583,8 @@ 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 fd19321..cd079a0 100644
--- a/repair/avl64.h
+++ b/repair/avl64.h
@@ -32,8 +32,8 @@ typedef struct avl64node {
* avl-tree operations
*/
typedef struct avl64ops {
- __uint64_t (*avl_start)(avl64node_t *);
- __uint64_t (*avl_end)(avl64node_t *);
+ uint64_t (*avl_start)(avl64node_t *);
+ uint64_t (*avl_end)(avl64node_t *);
} avl64ops_t;
/*
@@ -89,32 +89,32 @@ avl64_init_tree(
avl64node_t *
avl64_findrange(
avl64tree_desc_t *tree,
- __uint64_t value);
+ uint64_t value);
avl64node_t *
avl64_find(
avl64tree_desc_t *tree,
- __uint64_t value);
+ uint64_t value);
avl64node_t *
avl64_findanyrange(
avl64tree_desc_t *tree,
- __uint64_t start,
- __uint64_t end,
+ uint64_t start,
+ uint64_t end,
int checklen);
avl64node_t *
avl64_findadjacent(
avl64tree_desc_t *tree,
- __uint64_t value,
+ uint64_t value,
int dir);
void
avl64_findranges(
avl64tree_desc_t *tree,
- __uint64_t start,
- __uint64_t end,
+ uint64_t start,
+ uint64_t end,
avl64node_t **startp,
avl64node_t **endp);
diff --git a/repair/dino_chunks.c b/repair/dino_chunks.c
index 7dbaca6..ecfd0f1 100644
--- a/repair/dino_chunks.c
+++ b/repair/dino_chunks.c
@@ -826,7 +826,7 @@ next_readbuf:
* we do now, this is where to start.
*/
if (is_used) {
- __uint16_t di_mode;
+ uint16_t di_mode;
if (is_inode_free(ino_rec, irec_offset)) {
if (verbose || no_modify) {
diff --git a/repair/dinode.c b/repair/dinode.c
index df28e9e..3f3bf08 100644
--- a/repair/dinode.c
+++ b/repair/dinode.c
@@ -742,7 +742,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_UNKNOWN:
set_bmap_ext(agno, agbno, blen, XR_E_INUSE);
@@ -888,7 +888,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)
@@ -904,7 +904,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);
@@ -1063,7 +1063,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)
@@ -1165,14 +1165,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;
}
@@ -1414,22 +1414,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, "
@@ -1703,12 +1703,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;
}
@@ -1777,8 +1777,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)
{
@@ -1868,7 +1868,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)
{
@@ -1977,7 +1977,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)
@@ -2188,8 +2188,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;
@@ -2306,7 +2306,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 5aebf5b..42a526b 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 61912d1..3bff438 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 efd1d03..1a55d78 100644
--- a/repair/globals.h
+++ b/repair/globals.h
@@ -140,7 +140,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 */
@@ -160,16 +160,16 @@ EXTERN int full_ino_ex_data;/*
/* superblock counters */
-EXTERN __uint64_t sb_icount; /* allocated (made) inodes */
-EXTERN __uint64_t sb_ifree; /* free inodes */
-EXTERN __uint64_t sb_fdblocks; /* free data blocks */
-EXTERN __uint64_t sb_frextents; /* free realtime extents */
+EXTERN uint64_t sb_icount; /* allocated (made) inodes */
+EXTERN uint64_t sb_ifree; /* free inodes */
+EXTERN uint64_t sb_fdblocks; /* free data blocks */
+EXTERN uint64_t sb_frextents; /* free realtime extents */
/* superblock geometry info */
EXTERN xfs_extlen_t sb_inoalignmt;
-EXTERN __uint32_t sb_unit;
-EXTERN __uint32_t sb_width;
+EXTERN uint32_t sb_unit;
+EXTERN uint32_t sb_width;
struct aglock {
pthread_mutex_t lock __attribute__((__aligned__(64)));
@@ -177,7 +177,7 @@ struct aglock {
EXTERN struct aglock *ag_locks;
EXTERN int report_interval;
-EXTERN __uint64_t *prog_rpt_done;
+EXTERN uint64_t *prog_rpt_done;
EXTERN int ag_stride;
EXTERN int thread_count;
diff --git a/repair/incore.c b/repair/incore.c
index cb57316..a9191ae 100644
--- a/repair/incore.c
+++ b/repair/incore.c
@@ -179,7 +179,7 @@ get_bmap_ext(
static uint64_t *rt_bmap;
static size_t rt_bmap_size;
-/* block records fit into __uint64_t's units */
+/* block records fit into uint64_t's units */
#define XR_BB_UNIT 64 /* number of bits/unit */
#define XR_BB 4 /* bits per block record */
#define XR_BB_NUM (XR_BB_UNIT/XR_BB) /* number of records per unit */
@@ -203,8 +203,8 @@ set_rtbmap(
{
*(rt_bmap + bno / XR_BB_NUM) =
((*(rt_bmap + bno / XR_BB_NUM) &
- (~((__uint64_t) XR_BB_MASK << ((bno % XR_BB_NUM) * XR_BB)))) |
- (((__uint64_t) state) << ((bno % XR_BB_NUM) * XR_BB)));
+ (~((uint64_t) XR_BB_MASK << ((bno % XR_BB_NUM) * XR_BB)))) |
+ (((uint64_t) state) << ((bno % XR_BB_NUM) * XR_BB)));
}
static void
@@ -222,9 +222,9 @@ init_rt_bmap(
return;
rt_bmap_size = roundup(mp->m_sb.sb_rextents / (NBBY / XR_BB),
- sizeof(__uint64_t));
+ sizeof(uint64_t));
- rt_bmap = memalign(sizeof(__uint64_t), rt_bmap_size);
+ rt_bmap = memalign(sizeof(uint64_t), rt_bmap_size);
if (!rt_bmap) {
do_error(
_("couldn't allocate realtime block map, size = %" PRIu64 "\n"),
diff --git a/repair/incore.h b/repair/incore.h
index c92475e..c0b593d 100644
--- a/repair/incore.h
+++ b/repair/incore.h
@@ -261,7 +261,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;
@@ -269,14 +269,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;
@@ -285,20 +285,20 @@ 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 */
- __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 */
+ 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);
@@ -509,10 +509,10 @@ static inline bool is_inode_sparse(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)
{
@@ -533,13 +533,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)
@@ -572,11 +572,11 @@ typedef struct bm_level_state {
xfs_fsblock_t fsbno;
xfs_fsblock_t left_fsbno;
xfs_fsblock_t right_fsbno;
- __uint64_t first_key;
- __uint64_t last_key;
+ uint64_t first_key;
+ uint64_t last_key;
/*
int level;
- __uint64_t prev_last_key;
+ uint64_t prev_last_key;
xfs_buf_t *bp;
xfs_bmbt_block_t *block;
*/
diff --git a/repair/incore_ext.c b/repair/incore_ext.c
index 7e6786c..0a8138a 100644
--- a/repair/incore_ext.c
+++ b/repair/incore_ext.c
@@ -721,13 +721,13 @@ search_rt_dup_extent(xfs_mount_t *mp, xfs_rtblock_t bno)
return(ret);
}
-static __uint64_t
+static uint64_t
avl64_rt_ext_start(avl64node_t *node)
{
return(((rt_extent_tree_node_t *) node)->rt_startblock);
}
-static __uint64_t
+static uint64_t
avl64_ext_end(avl64node_t *node)
{
return(((rt_extent_tree_node_t *) node)->rt_startblock +
@@ -834,7 +834,7 @@ count_extents(xfs_agnumber_t agno, avltree_desc_t *tree, int whichtree)
int
count_bno_extents_blocks(xfs_agnumber_t agno, uint *numblocks)
{
- __uint64_t nblocks;
+ uint64_t nblocks;
extent_tree_node_t *node;
int i = 0;
diff --git a/repair/incore_ino.c b/repair/incore_ino.c
index 1898257..6ffe08e 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;
@@ -260,23 +260,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:
@@ -607,7 +607,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)
@@ -697,7 +697,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;
@@ -738,15 +738,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 e21ffa6..a2dfa0b 100644
--- a/repair/phase2.c
+++ b/repair/phase2.c
@@ -173,7 +173,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 76c9440..398c60c 100644
--- a/repair/phase3.c
+++ b/repair/phase3.c
@@ -98,7 +98,7 @@ phase3(xfs_mount_t *mp)
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) {
@@ -118,7 +118,7 @@ phase3(xfs_mount_t *mp)
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);
@@ -128,7 +128,7 @@ phase3(xfs_mount_t *mp)
* 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);
do {
/*
* have to loop until no ag has any uncertain
diff --git a/repair/phase4.c b/repair/phase4.c
index 1a7d7b5..90386c2 100644
--- a/repair/phase4.c
+++ b/repair/phase4.c
@@ -175,7 +175,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));
@@ -289,7 +289,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 5d48848..c280292 100644
--- a/repair/phase5.c
+++ b/repair/phase5.c
@@ -83,9 +83,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)
@@ -618,14 +618,14 @@ calculate_freespace_cursor(xfs_mount_t *mp, xfs_agnumber_t agno,
static void
prop_freespace_cursor(xfs_mount_t *mp, xfs_agnumber_t agno,
bt_status_t *btree_curs, xfs_agblock_t startblock,
- xfs_extlen_t blockcount, int level, __uint32_t magic)
+ xfs_extlen_t blockcount, int level, uint32_t magic)
{
struct xfs_btree_block *bt_hdr;
xfs_alloc_key_t *bt_key;
xfs_alloc_ptr_t *bt_ptr;
xfs_agblock_t agbno;
bt_stat_level_t *lptr;
- __uint32_t crc_magic;
+ uint32_t crc_magic;
if (magic == XFS_ABTB_MAGIC)
crc_magic = XFS_ABTB_CRC_MAGIC;
@@ -720,7 +720,7 @@ prop_freespace_cursor(xfs_mount_t *mp, xfs_agnumber_t agno,
*/
static xfs_extlen_t
build_freespace_tree(xfs_mount_t *mp, xfs_agnumber_t agno,
- bt_status_t *btree_curs, __uint32_t magic)
+ bt_status_t *btree_curs, uint32_t magic)
{
xfs_agnumber_t i;
xfs_agblock_t j;
@@ -731,7 +731,7 @@ build_freespace_tree(xfs_mount_t *mp, xfs_agnumber_t agno,
extent_tree_node_t *ext_ptr;
bt_stat_level_t *lptr;
xfs_extlen_t freeblks;
- __uint32_t crc_magic;
+ uint32_t crc_magic;
#ifdef XR_BLD_FREE_TRACE
fprintf(stderr, "in build_freespace_tree, agno = %d\n", agno);
@@ -895,10 +895,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;
@@ -1144,7 +1144,7 @@ build_agi(xfs_mount_t *mp, xfs_agnumber_t agno, bt_status_t *btree_curs,
*/
static void
build_ino_tree(xfs_mount_t *mp, xfs_agnumber_t agno,
- bt_status_t *btree_curs, __uint32_t magic,
+ bt_status_t *btree_curs, uint32_t magic,
struct agi_stat *agi_stat, int finobt)
{
xfs_agnumber_t i;
@@ -1573,10 +1573,10 @@ phase5_func(
xfs_mount_t *mp,
xfs_agnumber_t agno)
{
- __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;
@@ -1588,7 +1588,7 @@ phase5_func(
xfs_extlen_t freeblks2;
#endif
xfs_agblock_t num_extents;
- __uint32_t magic;
+ uint32_t magic;
struct agi_stat agi_stat = {0,};
if (verbose)
@@ -1772,7 +1772,7 @@ phase5(xfs_mount_t *mp)
xfs_agnumber_t agno;
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",
@@ -1798,15 +1798,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 7680deb..437142a 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;
@@ -887,7 +887,7 @@ mk_root_dir(xfs_mount_t *mp)
memset(&ip->i_d, 0, xfs_icdinode_size(vers));
ip->i_d.di_magic = XFS_DINODE_MAGIC;
- ip->i_d.di_mode = (__uint16_t) mode|S_IFDIR;
+ ip->i_d.di_mode = (uint16_t) mode|S_IFDIR;
ip->i_d.di_version = vers;
ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
@@ -1839,8 +1839,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);
@@ -2750,8 +2750,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 b1e3a55..d8e788e 100644
--- a/repair/phase7.c
+++ b/repair/phase7.c
@@ -32,7 +32,7 @@ static void
set_nlinks(
xfs_icdinode_t *dinoc,
xfs_ino_t ino,
- __uint32_t nrefs,
+ uint32_t nrefs,
int *dirty)
{
if (dinoc->di_nlink == nrefs)
@@ -56,7 +56,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;
@@ -114,7 +114,7 @@ phase7(xfs_mount_t *mp)
ino_tree_node_t *irec;
int i;
int j;
- __uint32_t nrefs;
+ uint32_t nrefs;
if (!no_modify)
do_log(_("Phase 7 - verify and correct link counts...\n"));
diff --git a/repair/progress.c b/repair/progress.c
index 418b803..eae14e7 100644
--- a/repair/progress.c
+++ b/repair/progress.c
@@ -85,8 +85,8 @@ pthread_t report_thread;
typedef struct msg_block_s {
pthread_mutex_t mutex;
progress_rpt_t *format;
- __uint64_t *done;
- __uint64_t *total;
+ uint64_t *done;
+ uint64_t *total;
int count;
int interval;
} msg_block_t;
@@ -96,14 +96,14 @@ typedef struct phase_times_s {
time_t start;
time_t end;
time_t duration;
- __uint64_t item_counts[4];
+ uint64_t item_counts[4];
} phase_times_t;
static phase_times_t phase_times[8];
static void *progress_rpt_thread(void *);
static int current_phase;
static int running;
-static __uint64_t prog_rpt_total;
+static uint64_t prog_rpt_total;
void
init_progress_rpt (void)
@@ -113,11 +113,11 @@ init_progress_rpt (void)
* allocate the done vector
*/
- if ((prog_rpt_done = (__uint64_t *)
- malloc(sizeof(__uint64_t)*glob_agcount)) == NULL ) {
+ if ((prog_rpt_done = (uint64_t *)
+ malloc(sizeof(uint64_t)*glob_agcount)) == NULL ) {
do_error(_("cannot malloc pointer to done vector\n"));
}
- bzero(prog_rpt_done, sizeof(__uint64_t)*glob_agcount);
+ bzero(prog_rpt_done, sizeof(uint64_t)*glob_agcount);
/*
* Setup comm block, start the thread
@@ -165,10 +165,10 @@ progress_rpt_thread (void *p)
timer_t timerid;
struct itimerspec timespec;
char *msgbuf;
- __uint64_t *donep;
- __uint64_t sum;
+ uint64_t *donep;
+ uint64_t sum;
msg_block_t *msgp = (msg_block_t *)p;
- __uint64_t percent;
+ uint64_t percent;
/* It's possible to get here very early w/ no progress msg set */
if (!msgp->format)
@@ -286,7 +286,7 @@ progress_rpt_thread (void *p)
}
int
-set_progress_msg (int report, __uint64_t total)
+set_progress_msg (int report, uint64_t total)
{
if (!ag_stride)
@@ -300,7 +300,7 @@ set_progress_msg (int report, __uint64_t total)
/* reset all the accumulative totals */
if (prog_rpt_done)
- bzero(prog_rpt_done, sizeof(__uint64_t)*glob_agcount);
+ bzero(prog_rpt_done, sizeof(uint64_t)*glob_agcount);
if (pthread_mutex_unlock(&global_msgs.mutex))
do_error(_("set_progress_msg: cannot unlock progress mutex\n"));
@@ -308,14 +308,14 @@ set_progress_msg (int report, __uint64_t total)
return (0);
}
-__uint64_t
+uint64_t
print_final_rpt(void)
{
int i;
struct tm *tmp;
time_t now;
- __uint64_t *donep;
- __uint64_t sum;
+ uint64_t *donep;
+ uint64_t sum;
msg_block_t *msgp = &global_msgs;
char msgbuf[DURATION_BUF_SIZE];
diff --git a/repair/progress.h b/repair/progress.h
index 33db834..5152648 100644
--- a/repair/progress.h
+++ b/repair/progress.h
@@ -32,8 +32,8 @@
extern void init_progress_rpt(void);
extern void stop_progress_rpt(void);
extern void summary_report(void);
-extern int set_progress_msg(int report, __uint64_t total);
-extern __uint64_t print_final_rpt(void);
+extern int set_progress_msg(int report, uint64_t total);
+extern uint64_t print_final_rpt(void);
extern char *timestamp(int end, int phase, char *buf);
extern char *duration(int val, char *buf);
extern int do_parallel;
diff --git a/repair/sb.c b/repair/sb.c
index 4eef14a..ea89ca9 100644
--- a/repair/sb.c
+++ b/repair/sb.c
@@ -41,7 +41,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;
@@ -264,7 +264,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;
/* check magic number and version number */
@@ -329,13 +329,13 @@ verify_sb(char *sb_buf, xfs_sb_t *sb, int is_primary_sb)
if (sb->sb_dblocks == 0 ||
sb->sb_dblocks >
- ((__uint64_t)sb->sb_agcount * sb->sb_agblocks) ||
+ ((uint64_t)sb->sb_agcount * sb->sb_agblocks) ||
sb->sb_dblocks <
- ((__uint64_t)(sb->sb_agcount - 1) * sb->sb_agblocks
+ ((uint64_t)(sb->sb_agcount - 1) * sb->sb_agblocks
+ XFS_MIN_AG_BLOCKS))
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 964ff06..5a79325 100644
--- a/repair/scan.c
+++ b/repair/scan.c
@@ -40,12 +40,12 @@ 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 ifreecount;
- __uint32_t fibtfreecount;
+ uint64_t agfbtreeblks;
+ uint32_t agicount;
+ uint32_t agifreecount;
+ uint64_t fdblocks;
+ uint64_t ifreecount;
+ uint32_t fibtfreecount;
};
void
@@ -67,10 +67,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)
{
@@ -107,23 +107,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;
@@ -176,13 +176,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;
@@ -528,7 +528,7 @@ scan_allocbt(
xfs_agnumber_t agno,
int suspect,
int isroot,
- __uint32_t magic,
+ uint32_t magic,
void *priv)
{
struct aghdr_cnts *agcnts = priv;
@@ -1243,7 +1243,7 @@ scan_inobt(
xfs_agnumber_t agno,
int suspect,
int isroot,
- __uint32_t magic,
+ uint32_t magic,
void *priv)
{
struct aghdr_cnts *agcnts = priv;
@@ -1479,7 +1479,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)) {
@@ -1530,7 +1530,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)) {
@@ -1756,9 +1756,9 @@ scan_ags(
int scan_threads)
{
struct aghdr_cnts *agcnts;
- __uint64_t fdblocks = 0;
- __uint64_t icount = 0;
- __uint64_t ifreecount = 0;
+ uint64_t fdblocks = 0;
+ uint64_t icount = 0;
+ uint64_t ifreecount = 0;
xfs_agnumber_t i;
work_queue_t wq;
diff --git a/repair/scan.h b/repair/scan.h
index ea8c0bf..9bbe1e6 100644
--- a/repair/scan.h
+++ b/repair/scan.h
@@ -30,23 +30,23 @@ int scan_lbtree(
xfs_fsblock_t bno,
xfs_ino_t ino,
xfs_rfsblock_t *tot,
- __uint64_t *nex,
+ uint64_t *nex,
struct blkmap **blkmapp,
bmap_cursor_t *bm_cursor,
int isroot,
int check_dups,
int *dirty,
- __uint64_t magic),
+ uint64_t magic),
int type,
int whichfork,
xfs_ino_t ino,
xfs_rfsblock_t *tot,
- __uint64_t *nex,
+ uint64_t *nex,
struct blkmap **blkmapp,
bmap_cursor_t *bm_cursor,
int isroot,
int check_dups,
- __uint64_t magic,
+ uint64_t magic,
const struct xfs_buf_ops *ops);
int scan_bmapbt(
@@ -57,13 +57,13 @@ int scan_bmapbt(
xfs_fsblock_t bno,
xfs_ino_t ino,
xfs_rfsblock_t *tot,
- __uint64_t *nex,
+ uint64_t *nex,
struct blkmap **blkmapp,
bmap_cursor_t *bm_cursor,
int isroot,
int check_dups,
int *dirty,
- __uint64_t magic);
+ uint64_t magic);
void
scan_ags(
--
2.4.10
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply related [flat|nested] 31+ messages in thread
* [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat
[not found] <cover.1452627740.git.felix.janda@posteo.de>
2016-01-12 19:59 ` [PATCH 1/6] Move from __uint*_t types to uint*_t and likewise for __int*_t Felix Janda
@ 2016-01-12 19:59 ` Felix Janda
2016-01-12 21:24 ` Dave Chinner
` (3 more replies)
2016-01-12 19:59 ` [PATCH 3/6] fsr/xfs_fsr.c: Include <paths.h> for _PATH_MOUNTED Felix Janda
` (3 subsequent siblings)
5 siblings, 4 replies; 31+ messages in thread
From: Felix Janda @ 2016-01-12 19:59 UTC (permalink / raw)
To: xfs
ustat has been used to check whether a device file is mounted.
The function is deprecated and not supported by uclibc and musl.
Now do the check using the *mntent functions.
Based on patch by Natanael Copa <ncopa@alpinelinux.org>.
Signed-off-by: Felix Janda <felix.janda@posteo.de>
---
libxfs/linux.c | 29 ++++++++++++++++++++---------
1 file changed, 20 insertions(+), 9 deletions(-)
diff --git a/libxfs/linux.c b/libxfs/linux.c
index c532d65..e7adcf2 100644
--- a/libxfs/linux.c
+++ b/libxfs/linux.c
@@ -16,11 +16,8 @@
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#define ustat __kernel_ustat
#include <mntent.h>
#include <sys/stat.h>
-#undef ustat
-#include <sys/ustat.h>
#include <sys/mount.h>
#include <sys/ioctl.h>
#include <sys/sysinfo.h>
@@ -51,9 +48,10 @@ static int max_block_alignment;
int
platform_check_ismounted(char *name, char *block, struct stat64 *s, int verbose)
{
- /* Pad ust; pre-2.6.28 linux copies out too much in 32bit compat mode */
- struct ustat ust[2];
- struct stat64 st;
+ FILE *f;
+ struct stat64 st, mst;
+ struct mntent *mnt;
+ char mounts[MAXPATHLEN];
if (!s) {
if (stat64(block, &st) < 0)
@@ -63,14 +61,27 @@ platform_check_ismounted(char *name, char *block, struct stat64 *s, int verbose)
s = &st;
}
- if (ustat(s->st_rdev, ust) >= 0) {
+ strcpy(mounts, (!access(PROC_MOUNTED, R_OK)) ? PROC_MOUNTED : MOUNTED);
+ if ((f = setmntent(mounts, "r")) == NULL) {
+ fprintf(stderr,
+ _("%s: %s possibly contains a mounted filesystem\n"),
+ progname, name);
+ return 1;
+ }
+ while ((mnt = getmntent(f)) != NULL) {
+ if (stat64(mnt->mnt_dir, &mst) < 0)
+ continue;
+ if (mst.st_dev != s->st_rdev)
+ continue;
+
if (verbose)
fprintf(stderr,
_("%s: %s contains a mounted filesystem\n"),
progname, name);
- return 1;
+ break;
}
- return 0;
+ endmntent(f);
+ return mnt == NULL;
}
int
--
2.4.10
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply related [flat|nested] 31+ messages in thread
* [PATCH 3/6] fsr/xfs_fsr.c: Include <paths.h> for _PATH_MOUNTED
[not found] <cover.1452627740.git.felix.janda@posteo.de>
2016-01-12 19:59 ` [PATCH 1/6] Move from __uint*_t types to uint*_t and likewise for __int*_t Felix Janda
2016-01-12 19:59 ` [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat Felix Janda
@ 2016-01-12 19:59 ` Felix Janda
2016-01-13 7:55 ` Christoph Hellwig
2016-01-12 20:00 ` [PATCH 4/6] linux.h: Use off64_t instead of loff_t Felix Janda
` (2 subsequent siblings)
5 siblings, 1 reply; 31+ messages in thread
From: Felix Janda @ 2016-01-12 19:59 UTC (permalink / raw)
To: xfs
Fixes a compilation failure with musl libc
Signed-off-by: Felix Janda <felix.janda@posteo.de>
---
fsr/xfs_fsr.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/fsr/xfs_fsr.c b/fsr/xfs_fsr.c
index f32aced..8957f93 100644
--- a/fsr/xfs_fsr.c
+++ b/fsr/xfs_fsr.c
@@ -31,6 +31,7 @@
#include <sys/wait.h>
#include <sys/statvfs.h>
#include <sys/xattr.h>
+#include <paths.h>
#ifndef XFS_XFLAG_NODEFRAG
#define XFS_XFLAG_NODEFRAG 0x00002000 /* src dependancy, remove later */
--
2.4.10
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply related [flat|nested] 31+ messages in thread
* [PATCH 4/6] linux.h: Use off64_t instead of loff_t
[not found] <cover.1452627740.git.felix.janda@posteo.de>
` (2 preceding siblings ...)
2016-01-12 19:59 ` [PATCH 3/6] fsr/xfs_fsr.c: Include <paths.h> for _PATH_MOUNTED Felix Janda
@ 2016-01-12 20:00 ` Felix Janda
2016-01-13 7:55 ` Christoph Hellwig
2016-01-12 20:00 ` [PATCH 5/6] include/linux.h: Include <stdio.h> for fprintf and stderr Felix Janda
2016-01-12 20:00 ` [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c Felix Janda
5 siblings, 1 reply; 31+ messages in thread
From: Felix Janda @ 2016-01-12 20:00 UTC (permalink / raw)
To: xfs
These are equivalent on glibc, while musl does not know loff_t.
In the long run, it would be preferable to enable transparent LFS so
that off64_t could be replaced by off_t.
Signed-off-by: Felix Janda <felix.janda@posteo.de>
---
include/linux.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/include/linux.h b/include/linux.h
index 827dbe1..4872a1e 100644
--- a/include/linux.h
+++ b/include/linux.h
@@ -141,7 +141,7 @@ platform_discard_blocks(int fd, uint64_t start, uint64_t len)
#define EFSCORRUPTED EUCLEAN /* Filesystem is corrupted */
#define EFSBADCRC EBADMSG /* Bad CRC detected */
-typedef loff_t xfs_off_t;
+typedef off64_t xfs_off_t;
typedef uint64_t xfs_ino_t;
typedef uint32_t xfs_dev_t;
typedef int64_t xfs_daddr_t;
--
2.4.10
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply related [flat|nested] 31+ messages in thread
* [PATCH 5/6] include/linux.h: Include <stdio.h> for fprintf and stderr
[not found] <cover.1452627740.git.felix.janda@posteo.de>
` (3 preceding siblings ...)
2016-01-12 20:00 ` [PATCH 4/6] linux.h: Use off64_t instead of loff_t Felix Janda
@ 2016-01-12 20:00 ` Felix Janda
2016-01-13 7:55 ` Christoph Hellwig
2016-01-12 20:00 ` [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c Felix Janda
5 siblings, 1 reply; 31+ messages in thread
From: Felix Janda @ 2016-01-12 20:00 UTC (permalink / raw)
To: xfs
Signed-off-by: Felix Janda <felix.janda@posteo.de>
---
include/linux.h | 1 +
1 file changed, 1 insertion(+)
diff --git a/include/linux.h b/include/linux.h
index 4872a1e..a4acedc 100644
--- a/include/linux.h
+++ b/include/linux.h
@@ -29,6 +29,7 @@
#include <errno.h>
#include <endian.h>
#include <stdbool.h>
+#include <stdio.h>
#include <asm/types.h>
#include <mntent.h>
--
2.4.10
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply related [flat|nested] 31+ messages in thread
* [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c
[not found] <cover.1452627740.git.felix.janda@posteo.de>
` (4 preceding siblings ...)
2016-01-12 20:00 ` [PATCH 5/6] include/linux.h: Include <stdio.h> for fprintf and stderr Felix Janda
@ 2016-01-12 20:00 ` Felix Janda
2016-01-12 21:30 ` Dave Chinner
2016-01-13 7:58 ` Christoph Hellwig
5 siblings, 2 replies; 31+ messages in thread
From: Felix Janda @ 2016-01-12 20:00 UTC (permalink / raw)
To: xfs
Signed-off-by: Felix Janda <felix.janda@posteo.de>
---
configure.ac | 7 +++++++
include/builddefs.in | 4 ++++
io/Makefile | 10 ++++++++++
3 files changed, 21 insertions(+)
diff --git a/configure.ac b/configure.ac
index feee50a..3d6443a 100644
--- a/configure.ac
+++ b/configure.ac
@@ -135,5 +135,12 @@ AC_CHECK_SIZEOF([char *])
AC_TYPE_UMODE_T
AC_MANUAL_FORMAT
+AC_CHECK_MEMBERS([struct dirent.d_reclen],[],[],[[#include <dirent.h>]])
+AC_SUBST(ac_cv_member_struct_dirent_d_reclen)
+AC_CHECK_MEMBERS([struct dirent.d_off],[],[],[[#include <dirent.h>]])
+AC_SUBST(ac_cv_member_struct_dirent_d_off)
+AC_CHECK_MEMBERS([struct dirent.d_type],[],[],[[#include <dirent.h>]])
+AC_SUBST(ac_cv_member_struct_dirent_d_type)
+
AC_CONFIG_FILES([include/builddefs])
AC_OUTPUT
diff --git a/include/builddefs.in b/include/builddefs.in
index b5ce336..67d963c 100644
--- a/include/builddefs.in
+++ b/include/builddefs.in
@@ -109,6 +109,10 @@ HAVE_FLS = @have_fls@
HAVE_FSETXATTR = @have_fsetxattr@
HAVE_MREMAP = @have_mremap@
+HAVE_STRUCT_DIRENT_D_RECLEN = @ac_cv_member_struct_dirent_d_reclen@
+HAVE_STRUCT_DIRENT_D_OFF = @ac_cv_member_struct_dirent_d_off@
+HAVE_STRUCT_DIRENT_D_TYPE = @ac_cv_member_struct_dirent_d_type@
+
GCCFLAGS = -funsigned-char -fno-strict-aliasing -Wall
# -Wbitwise -Wno-transparent-union -Wno-old-initializer -Wno-decl
diff --git a/io/Makefile b/io/Makefile
index 0b53f41..9574168 100644
--- a/io/Makefile
+++ b/io/Makefile
@@ -94,6 +94,16 @@ ifeq ($(HAVE_MREMAP),yes)
LCFLAGS += -DHAVE_MREMAP
endif
+ifeq ($(HAVE_STRUCT_DIRENT_D_RECLEN),yes)
+LCFLAGS += -D_DIRENT_HAVE_D_RECLEN
+endif
+ifeq ($(HAVE_STRUCT_DIRENT_D_OFF),yes)
+LCFLAGS += -D_DIRENT_HAVE_D_OFF
+endif
+ifeq ($(HAVE_STRUCT_DIRENT_D_TYPE),yes)
+LCFLAGS += -D_DIRENT_HAVE_D_TYPE
+endif
+
default: depend $(LTCOMMAND)
include $(BUILDRULES)
--
2.4.10
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply related [flat|nested] 31+ messages in thread
* Re: [PATCH 1/6] Move from __uint*_t types to uint*_t and likewise for __int*_t
2016-01-12 19:59 ` [PATCH 1/6] Move from __uint*_t types to uint*_t and likewise for __int*_t Felix Janda
@ 2016-01-12 21:24 ` Dave Chinner
2016-01-12 21:46 ` Felix Janda
2016-01-13 7:48 ` Christoph Hellwig
0 siblings, 2 replies; 31+ messages in thread
From: Dave Chinner @ 2016-01-12 21:24 UTC (permalink / raw)
To: Felix Janda; +Cc: xfs
On Tue, Jan 12, 2016 at 08:59:35PM +0100, Felix Janda wrote:
> The uint*_t and int*_t are defined by C99 and should be prefered
> over the less portable __uint*_t and __int*_t variants. The
> necessary <stdint.h> include is in platformdefs.h, which gets
> included in most places via libxfs.h. In the public headers
> <stdint.h> is included in <xfs/xfs_types.h>.
>
> Signed-off-by: Felix Janda <felix.janda@posteo.de>
I can't apply this straight off. Most of the libxfs code that is
changed is shared with the kernel code, and so the definitions of
the variables need to be the same as the kernel code. There are
reasons for the kernel code using __[u]int*_t type variants (e.g. I
think the endian conversion static checker requires the __ variants
for host order variables), and so before making sweeping changes
like this we need to ensure that we can make the equivalent changes
to the kernel code as well...
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat
2016-01-12 19:59 ` [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat Felix Janda
@ 2016-01-12 21:24 ` Dave Chinner
2016-01-12 21:33 ` Felix Janda
2016-01-13 7:55 ` Christoph Hellwig
` (2 subsequent siblings)
3 siblings, 1 reply; 31+ messages in thread
From: Dave Chinner @ 2016-01-12 21:24 UTC (permalink / raw)
To: Felix Janda; +Cc: xfs
On Tue, Jan 12, 2016 at 08:59:45PM +0100, Felix Janda wrote:
> ustat has been used to check whether a device file is mounted.
> The function is deprecated and not supported by uclibc and musl.
> Now do the check using the *mntent functions.
Which will cause problems with builds on other platforms. Why not
just use statfs() instead?
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c
2016-01-12 20:00 ` [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c Felix Janda
@ 2016-01-12 21:30 ` Dave Chinner
2016-01-12 21:37 ` Felix Janda
2016-01-13 7:58 ` Christoph Hellwig
1 sibling, 1 reply; 31+ messages in thread
From: Dave Chinner @ 2016-01-12 21:30 UTC (permalink / raw)
To: Felix Janda; +Cc: xfs
On Tue, Jan 12, 2016 at 09:00:22PM +0100, Felix Janda wrote:
> Signed-off-by: Felix Janda <felix.janda@posteo.de>
> ---
> configure.ac | 7 +++++++
> include/builddefs.in | 4 ++++
> io/Makefile | 10 ++++++++++
> 3 files changed, 21 insertions(+)
>
> diff --git a/configure.ac b/configure.ac
> index feee50a..3d6443a 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -135,5 +135,12 @@ AC_CHECK_SIZEOF([char *])
> AC_TYPE_UMODE_T
> AC_MANUAL_FORMAT
>
> +AC_CHECK_MEMBERS([struct dirent.d_reclen],[],[],[[#include <dirent.h>]])
> +AC_SUBST(ac_cv_member_struct_dirent_d_reclen)
> +AC_CHECK_MEMBERS([struct dirent.d_off],[],[],[[#include <dirent.h>]])
> +AC_SUBST(ac_cv_member_struct_dirent_d_off)
> +AC_CHECK_MEMBERS([struct dirent.d_type],[],[],[[#include <dirent.h>]])
> +AC_SUBST(ac_cv_member_struct_dirent_d_type)
> +
> AC_CONFIG_FILES([include/builddefs])
> AC_OUTPUT
> diff --git a/include/builddefs.in b/include/builddefs.in
> index b5ce336..67d963c 100644
> --- a/include/builddefs.in
> +++ b/include/builddefs.in
> @@ -109,6 +109,10 @@ HAVE_FLS = @have_fls@
> HAVE_FSETXATTR = @have_fsetxattr@
> HAVE_MREMAP = @have_mremap@
>
> +HAVE_STRUCT_DIRENT_D_RECLEN = @ac_cv_member_struct_dirent_d_reclen@
> +HAVE_STRUCT_DIRENT_D_OFF = @ac_cv_member_struct_dirent_d_off@
> +HAVE_STRUCT_DIRENT_D_TYPE = @ac_cv_member_struct_dirent_d_type@
> +
> GCCFLAGS = -funsigned-char -fno-strict-aliasing -Wall
> # -Wbitwise -Wno-transparent-union -Wno-old-initializer -Wno-decl
>
> diff --git a/io/Makefile b/io/Makefile
> index 0b53f41..9574168 100644
> --- a/io/Makefile
> +++ b/io/Makefile
> @@ -94,6 +94,16 @@ ifeq ($(HAVE_MREMAP),yes)
> LCFLAGS += -DHAVE_MREMAP
> endif
>
> +ifeq ($(HAVE_STRUCT_DIRENT_D_RECLEN),yes)
> +LCFLAGS += -D_DIRENT_HAVE_D_RECLEN
> +endif
The C library should be defining these if those fields are
supported, right?
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat
2016-01-12 21:24 ` Dave Chinner
@ 2016-01-12 21:33 ` Felix Janda
0 siblings, 0 replies; 31+ messages in thread
From: Felix Janda @ 2016-01-12 21:33 UTC (permalink / raw)
To: Dave Chinner; +Cc: xfs
Dave Chinner wrote:
> On Tue, Jan 12, 2016 at 08:59:45PM +0100, Felix Janda wrote:
> > ustat has been used to check whether a device file is mounted.
> > The function is deprecated and not supported by uclibc and musl.
> > Now do the check using the *mntent functions.
>
> Which will cause problems with builds on other platforms.
This is the linux specific code...
> Why not
> just use statfs() instead?
Since it does not have the functionality which ustat is used for.
Felix
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c
2016-01-12 21:30 ` Dave Chinner
@ 2016-01-12 21:37 ` Felix Janda
2016-01-12 22:37 ` Dave Chinner
0 siblings, 1 reply; 31+ messages in thread
From: Felix Janda @ 2016-01-12 21:37 UTC (permalink / raw)
To: Dave Chinner; +Cc: xfs
Dave Chinner wrote:
> On Tue, Jan 12, 2016 at 09:00:22PM +0100, Felix Janda wrote:
> > Signed-off-by: Felix Janda <felix.janda@posteo.de>
> > ---
> > configure.ac | 7 +++++++
> > include/builddefs.in | 4 ++++
> > io/Makefile | 10 ++++++++++
> > 3 files changed, 21 insertions(+)
> >
> > diff --git a/configure.ac b/configure.ac
> > index feee50a..3d6443a 100644
> > --- a/configure.ac
> > +++ b/configure.ac
> > @@ -135,5 +135,12 @@ AC_CHECK_SIZEOF([char *])
> > AC_TYPE_UMODE_T
> > AC_MANUAL_FORMAT
> >
> > +AC_CHECK_MEMBERS([struct dirent.d_reclen],[],[],[[#include <dirent.h>]])
> > +AC_SUBST(ac_cv_member_struct_dirent_d_reclen)
> > +AC_CHECK_MEMBERS([struct dirent.d_off],[],[],[[#include <dirent.h>]])
> > +AC_SUBST(ac_cv_member_struct_dirent_d_off)
> > +AC_CHECK_MEMBERS([struct dirent.d_type],[],[],[[#include <dirent.h>]])
> > +AC_SUBST(ac_cv_member_struct_dirent_d_type)
> > +
> > AC_CONFIG_FILES([include/builddefs])
> > AC_OUTPUT
> > diff --git a/include/builddefs.in b/include/builddefs.in
> > index b5ce336..67d963c 100644
> > --- a/include/builddefs.in
> > +++ b/include/builddefs.in
> > @@ -109,6 +109,10 @@ HAVE_FLS = @have_fls@
> > HAVE_FSETXATTR = @have_fsetxattr@
> > HAVE_MREMAP = @have_mremap@
> >
> > +HAVE_STRUCT_DIRENT_D_RECLEN = @ac_cv_member_struct_dirent_d_reclen@
> > +HAVE_STRUCT_DIRENT_D_OFF = @ac_cv_member_struct_dirent_d_off@
> > +HAVE_STRUCT_DIRENT_D_TYPE = @ac_cv_member_struct_dirent_d_type@
> > +
> > GCCFLAGS = -funsigned-char -fno-strict-aliasing -Wall
> > # -Wbitwise -Wno-transparent-union -Wno-old-initializer -Wno-decl
> >
> > diff --git a/io/Makefile b/io/Makefile
> > index 0b53f41..9574168 100644
> > --- a/io/Makefile
> > +++ b/io/Makefile
> > @@ -94,6 +94,16 @@ ifeq ($(HAVE_MREMAP),yes)
> > LCFLAGS += -DHAVE_MREMAP
> > endif
> >
> > +ifeq ($(HAVE_STRUCT_DIRENT_D_RECLEN),yes)
> > +LCFLAGS += -D_DIRENT_HAVE_D_RECLEN
> > +endif
>
> The C library should be defining these if those fields are
> supported, right?
It is strongly advised not to use these non-standard fields of dirent.
These macros are a feature of glibc. See also
https://seiscode.iris.washington.edu/issues/676
Felix
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 1/6] Move from __uint*_t types to uint*_t and likewise for __int*_t
2016-01-12 21:24 ` Dave Chinner
@ 2016-01-12 21:46 ` Felix Janda
2016-01-12 22:02 ` Dave Chinner
2016-01-13 7:48 ` Christoph Hellwig
1 sibling, 1 reply; 31+ messages in thread
From: Felix Janda @ 2016-01-12 21:46 UTC (permalink / raw)
To: Dave Chinner; +Cc: xfs
Dave Chinner wrote:
> On Tue, Jan 12, 2016 at 08:59:35PM +0100, Felix Janda wrote:
> > The uint*_t and int*_t are defined by C99 and should be prefered
> > over the less portable __uint*_t and __int*_t variants. The
> > necessary <stdint.h> include is in platformdefs.h, which gets
> > included in most places via libxfs.h. In the public headers
> > <stdint.h> is included in <xfs/xfs_types.h>.
> >
> > Signed-off-by: Felix Janda <felix.janda@posteo.de>
>
> I can't apply this straight off. Most of the libxfs code that is
> changed is shared with the kernel code, and so the definitions of
> the variables need to be the same as the kernel code. There are
> reasons for the kernel code using __[u]int*_t type variants (e.g. I
> think the endian conversion static checker requires the __ variants
> for host order variables), and so before making sweeping changes
> like this we need to ensure that we can make the equivalent changes
> to the kernel code as well...
Thanks for the review!
Sorry, I was not aware about this difference between the types.
The simplest fix for musl would be to add defines or something similar
to linux.h.
On the other hand, on the long run it would be preferable to use
the stdint types (consistently).
Felix
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 1/6] Move from __uint*_t types to uint*_t and likewise for __int*_t
2016-01-12 21:46 ` Felix Janda
@ 2016-01-12 22:02 ` Dave Chinner
0 siblings, 0 replies; 31+ messages in thread
From: Dave Chinner @ 2016-01-12 22:02 UTC (permalink / raw)
To: Felix Janda; +Cc: xfs
On Tue, Jan 12, 2016 at 10:46:34PM +0100, Felix Janda wrote:
> Dave Chinner wrote:
> > On Tue, Jan 12, 2016 at 08:59:35PM +0100, Felix Janda wrote:
> > > The uint*_t and int*_t are defined by C99 and should be prefered
> > > over the less portable __uint*_t and __int*_t variants. The
> > > necessary <stdint.h> include is in platformdefs.h, which gets
> > > included in most places via libxfs.h. In the public headers
> > > <stdint.h> is included in <xfs/xfs_types.h>.
> > >
> > > Signed-off-by: Felix Janda <felix.janda@posteo.de>
> >
> > I can't apply this straight off. Most of the libxfs code that is
> > changed is shared with the kernel code, and so the definitions of
> > the variables need to be the same as the kernel code. There are
> > reasons for the kernel code using __[u]int*_t type variants (e.g. I
> > think the endian conversion static checker requires the __ variants
> > for host order variables), and so before making sweeping changes
> > like this we need to ensure that we can make the equivalent changes
> > to the kernel code as well...
>
> Thanks for the review!
>
> Sorry, I was not aware about this difference between the types.
>
> The simplest fix for musl would be to add defines or something similar
> to linux.h.
>
> On the other hand, on the long run it would be preferable to use
> the stdint types (consistently).
Right, that's definitely the better solution. We can't just jump
there in one go. :/
FWIW, changing everything outside libxfs/ and include/ should be ok
to do straight away; it's just the libxfs stuff that we have other
constraints on.
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c
2016-01-12 21:37 ` Felix Janda
@ 2016-01-12 22:37 ` Dave Chinner
0 siblings, 0 replies; 31+ messages in thread
From: Dave Chinner @ 2016-01-12 22:37 UTC (permalink / raw)
To: Felix Janda; +Cc: xfs
On Tue, Jan 12, 2016 at 10:37:11PM +0100, Felix Janda wrote:
> Dave Chinner wrote:
> > On Tue, Jan 12, 2016 at 09:00:22PM +0100, Felix Janda wrote:
> > > Signed-off-by: Felix Janda <felix.janda@posteo.de>
> > > ---
> > > configure.ac | 7 +++++++
> > > include/builddefs.in | 4 ++++
> > > io/Makefile | 10 ++++++++++
> > > 3 files changed, 21 insertions(+)
> > >
> > > diff --git a/configure.ac b/configure.ac
> > > index feee50a..3d6443a 100644
> > > --- a/configure.ac
> > > +++ b/configure.ac
> > > @@ -135,5 +135,12 @@ AC_CHECK_SIZEOF([char *])
> > > AC_TYPE_UMODE_T
> > > AC_MANUAL_FORMAT
> > >
> > > +AC_CHECK_MEMBERS([struct dirent.d_reclen],[],[],[[#include <dirent.h>]])
> > > +AC_SUBST(ac_cv_member_struct_dirent_d_reclen)
> > > +AC_CHECK_MEMBERS([struct dirent.d_off],[],[],[[#include <dirent.h>]])
> > > +AC_SUBST(ac_cv_member_struct_dirent_d_off)
> > > +AC_CHECK_MEMBERS([struct dirent.d_type],[],[],[[#include <dirent.h>]])
> > > +AC_SUBST(ac_cv_member_struct_dirent_d_type)
> > > +
> > > AC_CONFIG_FILES([include/builddefs])
> > > AC_OUTPUT
> > > diff --git a/include/builddefs.in b/include/builddefs.in
> > > index b5ce336..67d963c 100644
> > > --- a/include/builddefs.in
> > > +++ b/include/builddefs.in
> > > @@ -109,6 +109,10 @@ HAVE_FLS = @have_fls@
> > > HAVE_FSETXATTR = @have_fsetxattr@
> > > HAVE_MREMAP = @have_mremap@
> > >
> > > +HAVE_STRUCT_DIRENT_D_RECLEN = @ac_cv_member_struct_dirent_d_reclen@
> > > +HAVE_STRUCT_DIRENT_D_OFF = @ac_cv_member_struct_dirent_d_off@
> > > +HAVE_STRUCT_DIRENT_D_TYPE = @ac_cv_member_struct_dirent_d_type@
> > > +
> > > GCCFLAGS = -funsigned-char -fno-strict-aliasing -Wall
> > > # -Wbitwise -Wno-transparent-union -Wno-old-initializer -Wno-decl
> > >
> > > diff --git a/io/Makefile b/io/Makefile
> > > index 0b53f41..9574168 100644
> > > --- a/io/Makefile
> > > +++ b/io/Makefile
> > > @@ -94,6 +94,16 @@ ifeq ($(HAVE_MREMAP),yes)
> > > LCFLAGS += -DHAVE_MREMAP
> > > endif
> > >
> > > +ifeq ($(HAVE_STRUCT_DIRENT_D_RECLEN),yes)
> > > +LCFLAGS += -D_DIRENT_HAVE_D_RECLEN
> > > +endif
> >
> > The C library should be defining these if those fields are
> > supported, right?
>
> It is strongly advised not to use these non-standard fields of dirent.
We're not writing POSIX applications here - this is a diagnostic
tool so if we are running on linux we need to expose them.
If we've got linux C libraries that don't provide feature macros for
the fields in the linux_dirent eposed by readdir(3), then I guess
we're stuck with having to play autoconf games, eh?
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 1/6] Move from __uint*_t types to uint*_t and likewise for __int*_t
2016-01-12 21:24 ` Dave Chinner
2016-01-12 21:46 ` Felix Janda
@ 2016-01-13 7:48 ` Christoph Hellwig
2016-01-20 0:46 ` Dave Chinner
1 sibling, 1 reply; 31+ messages in thread
From: Christoph Hellwig @ 2016-01-13 7:48 UTC (permalink / raw)
To: Dave Chinner; +Cc: Felix Janda, xfs
On Wed, Jan 13, 2016 at 08:24:06AM +1100, Dave Chinner wrote:
> I can't apply this straight off. Most of the libxfs code that is
> changed is shared with the kernel code, and so the definitions of
> the variables need to be the same as the kernel code. There are
> reasons for the kernel code using __[u]int*_t type variants (e.g. I
> think the endian conversion static checker requires the __ variants
> for host order variables), and so before making sweeping changes
> like this we need to ensure that we can make the equivalent changes
> to the kernel code as well...
There is no functional requirement for these types. I'm not sure if
they are an IRIXism, or something that was added during the early
Linux port, but they certainly aren't nessecary.
I'd love to kill them in favour or either the kernel __u/s types or the
C99 types which are like the urrent ones just without the __ prefix.
Maybe we should get an agreement which ones we want and ask Felix for
a patch to the kernel tree?
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat
2016-01-12 19:59 ` [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat Felix Janda
2016-01-12 21:24 ` Dave Chinner
@ 2016-01-13 7:55 ` Christoph Hellwig
2016-01-13 17:42 ` Felix Janda
2016-09-04 1:23 ` Eric Sandeen
2016-09-08 0:00 ` Dave Chinner
3 siblings, 1 reply; 31+ messages in thread
From: Christoph Hellwig @ 2016-01-13 7:55 UTC (permalink / raw)
To: Felix Janda; +Cc: xfs
On Tue, Jan 12, 2016 at 08:59:45PM +0100, Felix Janda wrote:
> ustat has been used to check whether a device file is mounted.
> The function is deprecated and not supported by uclibc and musl.
> Now do the check using the *mntent functions.
>
> Based on patch by Natanael Copa <ncopa@alpinelinux.org>.
>
> Signed-off-by: Felix Janda <felix.janda@posteo.de>
ustat is a lot more efficient in checking for the mountedness
than this loop, so I'd really prefer not to do this unconditionally.
As far as Linux is concerned the best thing we could do is to use
O_EXCL for any open of a device file, as Linux overloadds O_EXCL
behavior for block devices so that any other O_EXCL open will
be rejected if one has the file open.
But that might be a major pain to find into the cross platform
framework..
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 3/6] fsr/xfs_fsr.c: Include <paths.h> for _PATH_MOUNTED
2016-01-12 19:59 ` [PATCH 3/6] fsr/xfs_fsr.c: Include <paths.h> for _PATH_MOUNTED Felix Janda
@ 2016-01-13 7:55 ` Christoph Hellwig
0 siblings, 0 replies; 31+ messages in thread
From: Christoph Hellwig @ 2016-01-13 7:55 UTC (permalink / raw)
To: Felix Janda; +Cc: xfs
On Tue, Jan 12, 2016 at 08:59:53PM +0100, Felix Janda wrote:
> Fixes a compilation failure with musl libc
>
> Signed-off-by: Felix Janda <felix.janda@posteo.de>
Looks fine,
Reviewed-by: Christoph Hellwig <hch@lst.de>
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 4/6] linux.h: Use off64_t instead of loff_t
2016-01-12 20:00 ` [PATCH 4/6] linux.h: Use off64_t instead of loff_t Felix Janda
@ 2016-01-13 7:55 ` Christoph Hellwig
0 siblings, 0 replies; 31+ messages in thread
From: Christoph Hellwig @ 2016-01-13 7:55 UTC (permalink / raw)
To: Felix Janda; +Cc: xfs
On Tue, Jan 12, 2016 at 09:00:01PM +0100, Felix Janda wrote:
> These are equivalent on glibc, while musl does not know loff_t.
>
> In the long run, it would be preferable to enable transparent LFS so
> that off64_t could be replaced by off_t.
>
> Signed-off-by: Felix Janda <felix.janda@posteo.de>
Looks fine,
Reviewed-by: Christoph Hellwig <hch@lst.de>
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 5/6] include/linux.h: Include <stdio.h> for fprintf and stderr
2016-01-12 20:00 ` [PATCH 5/6] include/linux.h: Include <stdio.h> for fprintf and stderr Felix Janda
@ 2016-01-13 7:55 ` Christoph Hellwig
0 siblings, 0 replies; 31+ messages in thread
From: Christoph Hellwig @ 2016-01-13 7:55 UTC (permalink / raw)
To: Felix Janda; +Cc: xfs
On Tue, Jan 12, 2016 at 09:00:08PM +0100, Felix Janda wrote:
> Signed-off-by: Felix Janda <felix.janda@posteo.de>
Looks fine,
Reviewed-by: Christoph Hellwig <hch@lst.de>
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c
2016-01-12 20:00 ` [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c Felix Janda
2016-01-12 21:30 ` Dave Chinner
@ 2016-01-13 7:58 ` Christoph Hellwig
2016-01-13 17:09 ` Felix Janda
1 sibling, 1 reply; 31+ messages in thread
From: Christoph Hellwig @ 2016-01-13 7:58 UTC (permalink / raw)
To: Felix Janda; +Cc: xfs
I think we're having a deeper issue here. For an LFS build we
absolutely should have these values as the kernel dirent64 has them.
Either we manage to not pull in the LFS version of readdir/getdents
or musl is doing something inredibly stupid. Can you investigate if
and why we're not using the LFS getdents64 here?
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c
2016-01-13 7:58 ` Christoph Hellwig
@ 2016-01-13 17:09 ` Felix Janda
2016-01-14 10:17 ` Christoph Hellwig
0 siblings, 1 reply; 31+ messages in thread
From: Felix Janda @ 2016-01-13 17:09 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: xfs
Christoph Hellwig wrote:
> I think we're having a deeper issue here. For an LFS build we
> absolutely should have these values as the kernel dirent64 has them.
>
> Either we manage to not pull in the LFS version of readdir/getdents
> or musl is doing something inredibly stupid. Can you investigate if
> and why we're not using the LFS getdents64 here?
With musl you always have LFS. However still musl does not define the
_DIRENT_HAVE_*. You can see the full dirent.h at:
http://git.musl-libc.org/cgit/musl/tree/include/dirent.h
I will ask on the musl list whether these constants can be added. So
you can disregard this patch.
However notice that these constants are not defined when not on linux
or with glibc, e.g. freebsd (without k). On these systems the code in
io/readdir.c just happens to have worked because either
dirent.d_namelen exists or nobody has tested it on these systems.
Felix
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat
2016-01-13 7:55 ` Christoph Hellwig
@ 2016-01-13 17:42 ` Felix Janda
2016-01-14 10:20 ` Christoph Hellwig
0 siblings, 1 reply; 31+ messages in thread
From: Felix Janda @ 2016-01-13 17:42 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: xfs
Christoph Hellwig wrote:
> On Tue, Jan 12, 2016 at 08:59:45PM +0100, Felix Janda wrote:
> > ustat has been used to check whether a device file is mounted.
> > The function is deprecated and not supported by uclibc and musl.
> > Now do the check using the *mntent functions.
> >
> > Based on patch by Natanael Copa <ncopa@alpinelinux.org>.
> >
> > Signed-off-by: Felix Janda <felix.janda@posteo.de>
>
> ustat is a lot more efficient in checking for the mountedness
> than this loop, so I'd really prefer not to do this unconditionally.
Is this really performance relevant?
Notice that linux's platform_check_iswritable does something very
similar. I've tried to make it consistent with the version from
freebsd.c.
> As far as Linux is concerned the best thing we could do is to use
> O_EXCL for any open of a device file, as Linux overloadds O_EXCL
> behavior for block devices so that any other O_EXCL open will
> be rejected if one has the file open.
>
> But that might be a major pain to find into the cross platform
> framework..
Hmm, so we couldn't we use for linux just something like
int
platform_check_ismounted(char *name, char *block, struct stat64 *s, int verbose)
{
int fd = open(block, O_EXCL);
int e = errno;
if (fd != -1) close(fd);
if (e == EBUSY) {
if (verbose)
fprintf(stderr, _("%s: %s contains a mounted filesystem\n"), progname, name);
return 1;
}
return 0;
}
Felix
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c
2016-01-13 17:09 ` Felix Janda
@ 2016-01-14 10:17 ` Christoph Hellwig
2016-01-14 19:06 ` Felix Janda
0 siblings, 1 reply; 31+ messages in thread
From: Christoph Hellwig @ 2016-01-14 10:17 UTC (permalink / raw)
To: Felix Janda; +Cc: Christoph Hellwig, xfs
On Wed, Jan 13, 2016 at 06:09:38PM +0100, Felix Janda wrote:
> Christoph Hellwig wrote:
> > I think we're having a deeper issue here. For an LFS build we
> > absolutely should have these values as the kernel dirent64 has them.
> >
> > Either we manage to not pull in the LFS version of readdir/getdents
> > or musl is doing something inredibly stupid. Can you investigate if
> > and why we're not using the LFS getdents64 here?
>
> With musl you always have LFS. However still musl does not define the
> _DIRENT_HAVE_*. You can see the full dirent.h at:
>
> http://git.musl-libc.org/cgit/musl/tree/include/dirent.h
>
> I will ask on the musl list whether these constants can be added. So
> you can disregard this patch.
Oh, ok. That's a little weird, but I guess working around that
with a new autoconf test is fine.
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat
2016-01-13 17:42 ` Felix Janda
@ 2016-01-14 10:20 ` Christoph Hellwig
2016-01-14 19:07 ` Felix Janda
2016-06-18 14:53 ` Felix Janda
0 siblings, 2 replies; 31+ messages in thread
From: Christoph Hellwig @ 2016-01-14 10:20 UTC (permalink / raw)
To: Felix Janda; +Cc: Christoph Hellwig, xfs
On Wed, Jan 13, 2016 at 06:42:41PM +0100, Felix Janda wrote:
> Is this really performance relevant?
I'm not entirely sure. There are systems with giant amounts of mounted
file systems, in which case iterating each of them and requiring
multiple syscalls each might not be a good idea.
> Hmm, so we couldn't we use for linux just something like
>
> int
> platform_check_ismounted(char *name, char *block, struct stat64 *s, int verbose)
> {
> int fd = open(block, O_EXCL);
> int e = errno;
>
> if (fd != -1) close(fd);
> if (e == EBUSY) {
> if (verbose)
> fprintf(stderr, _("%s: %s contains a mounted filesystem\n"), progname, name);
> return 1;
> }
>
> return 0;
Please give me a couple of days to come up with an idea to use O_EXCL
on Linux and work around it on other platforms in a more integrated way.
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c
2016-01-14 10:17 ` Christoph Hellwig
@ 2016-01-14 19:06 ` Felix Janda
0 siblings, 0 replies; 31+ messages in thread
From: Felix Janda @ 2016-01-14 19:06 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: xfs
Christoph Hellwig wrote:
> On Wed, Jan 13, 2016 at 06:09:38PM +0100, Felix Janda wrote:
> > Christoph Hellwig wrote:
> > > I think we're having a deeper issue here. For an LFS build we
> > > absolutely should have these values as the kernel dirent64 has them.
> > >
> > > Either we manage to not pull in the LFS version of readdir/getdents
> > > or musl is doing something inredibly stupid. Can you investigate if
> > > and why we're not using the LFS getdents64 here?
> >
> > With musl you always have LFS. However still musl does not define the
> > _DIRENT_HAVE_*. You can see the full dirent.h at:
> >
> > http://git.musl-libc.org/cgit/musl/tree/include/dirent.h
> >
> > I will ask on the musl list whether these constants can be added. So
> > you can disregard this patch.
>
> Oh, ok. That's a little weird, but I guess working around that
> with a new autoconf test is fine.
Actually, it should also be useful for other systems. For example, on
FreeBSD dirent has d_type (but does not declare _DIRENT_HAVE_D_TYPE),
but currently dump_dirent() does not print it.
Felix
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat
2016-01-14 10:20 ` Christoph Hellwig
@ 2016-01-14 19:07 ` Felix Janda
2016-06-18 14:53 ` Felix Janda
1 sibling, 0 replies; 31+ messages in thread
From: Felix Janda @ 2016-01-14 19:07 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: xfs
Christoph Hellwig wrote:
> On Wed, Jan 13, 2016 at 06:42:41PM +0100, Felix Janda wrote:
> > Is this really performance relevant?
>
> I'm not entirely sure. There are systems with giant amounts of mounted
> file systems, in which case iterating each of them and requiring
> multiple syscalls each might not be a good idea.
Of course, it is not very elegant...
> > Hmm, so we couldn't we use for linux just something like
> >
> > int
> > platform_check_ismounted(char *name, char *block, struct stat64 *s, int verbose)
> > {
> > int fd = open(block, O_EXCL);
> > int e = errno;
> >
> > if (fd != -1) close(fd);
> > if (e == EBUSY) {
> > if (verbose)
> > fprintf(stderr, _("%s: %s contains a mounted filesystem\n"), progname, name);
> > return 1;
> > }
> >
> > return 0;
>
> Please give me a couple of days to come up with an idea to use O_EXCL
> on Linux and work around it on other platforms in a more integrated way.
No problem. Thank you!
Felix
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 1/6] Move from __uint*_t types to uint*_t and likewise for __int*_t
2016-01-13 7:48 ` Christoph Hellwig
@ 2016-01-20 0:46 ` Dave Chinner
0 siblings, 0 replies; 31+ messages in thread
From: Dave Chinner @ 2016-01-20 0:46 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: Felix Janda, xfs
On Tue, Jan 12, 2016 at 11:48:59PM -0800, Christoph Hellwig wrote:
> On Wed, Jan 13, 2016 at 08:24:06AM +1100, Dave Chinner wrote:
> > I can't apply this straight off. Most of the libxfs code that is
> > changed is shared with the kernel code, and so the definitions of
> > the variables need to be the same as the kernel code. There are
> > reasons for the kernel code using __[u]int*_t type variants (e.g. I
> > think the endian conversion static checker requires the __ variants
> > for host order variables), and so before making sweeping changes
> > like this we need to ensure that we can make the equivalent changes
> > to the kernel code as well...
>
> There is no functional requirement for these types. I'm not sure if
> they are an IRIXism, or something that was added during the early
> Linux port, but they certainly aren't nessecary.
>
> I'd love to kill them in favour or either the kernel __u/s types or the
> C99 types which are like the urrent ones just without the __ prefix.
>
> Maybe we should get an agreement which ones we want and ask Felix for
> a patch to the kernel tree?
Either way is fine by me, but it's not a small patch - there's ~600
variables declared in fs/xfs with the __[u]int*_t types.
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat
2016-01-14 10:20 ` Christoph Hellwig
2016-01-14 19:07 ` Felix Janda
@ 2016-06-18 14:53 ` Felix Janda
2016-06-22 12:59 ` Christoph Hellwig
1 sibling, 1 reply; 31+ messages in thread
From: Felix Janda @ 2016-06-18 14:53 UTC (permalink / raw)
To: Christoph Hellwig; +Cc: xfs
On Thu, 14 Jan 2016 at 02:20:09 -0800, Christoph Hellwig wrote:
> On Wed, Jan 13, 2016 at 06:42:41PM +0100, Felix Janda wrote:
> > Is this really performance relevant?
>
> I'm not entirely sure. There are systems with giant amounts of mounted
> file systems, in which case iterating each of them and requiring
> multiple syscalls each might not be a good idea.
>
> > Hmm, so we couldn't we use for linux just something like
> >
> > int
> > platform_check_ismounted(char *name, char *block, struct stat64 *s, int verbose)
> > {
> > int fd = open(block, O_EXCL);
> > int e = errno;
> >
> > if (fd != -1) close(fd);
> > if (e == EBUSY) {
> > if (verbose)
> > fprintf(stderr, _("%s: %s contains a mounted filesystem\n"), progname, name);
> > return 1;
> > }
> >
> > return 0;
>
> Please give me a couple of days to come up with an idea to use O_EXCL
> on Linux and work around it on other platforms in a more integrated way.
Ping?
Thanks,
Felix
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat
2016-06-18 14:53 ` Felix Janda
@ 2016-06-22 12:59 ` Christoph Hellwig
0 siblings, 0 replies; 31+ messages in thread
From: Christoph Hellwig @ 2016-06-22 12:59 UTC (permalink / raw)
To: Felix Janda; +Cc: Christoph Hellwig, xfs
Sorr for not getting back to you. It turns out that simply using
O_EXCL is fairly easy, but fitting it into a portabilitity framework
isn't. So I think I'll have to give up on that attempt for now.
That being said I think ustat fits pretty well for this use case,
so getting rid of it might need a little more justification.
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat
2016-01-12 19:59 ` [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat Felix Janda
2016-01-12 21:24 ` Dave Chinner
2016-01-13 7:55 ` Christoph Hellwig
@ 2016-09-04 1:23 ` Eric Sandeen
2016-09-08 0:00 ` Dave Chinner
3 siblings, 0 replies; 31+ messages in thread
From: Eric Sandeen @ 2016-09-04 1:23 UTC (permalink / raw)
To: xfs, Christoph Hellwig, linux-xfs
Ok, this has become a bit more urgent:
Building on F24 on arm64, I noticed this:
../libxfs/.libs/libxfs.a(linux.o): In function `platform_check_ismounted':
/root/sandeen/xfsprogs-dev/libxfs/linux.c:66: warning: ustat is not implemented and will always fail
And lo:
# xfs_metadump -o /dev/sda3 dump
# mount /dev/sda3 /mnt/scratch
# xfs_mdrestore dump /dev/sda3
# echo $?
0
#
Are we scared yet?
(I independently rewrote Felix's patch after seeing the above, then
searched and found this old thread)
We need to fix this, now. Performance issues or not I'd advocate for
taking this patch, unless hch made any progress on the O_EXCL approach.
hch said:
> That being said I think ustat fits pretty well for this use case,
> so getting rid of it might need a little more justification.
but it looks like that ship has sailed.
So for this patch I'll add:
Reviewed-by: Eric Sandeen <sandeen@redhat.com>
-Eric
On 1/12/16 1:59 PM, Felix Janda wrote:
> ustat has been used to check whether a device file is mounted.
> The function is deprecated and not supported by uclibc and musl.
> Now do the check using the *mntent functions.
>
> Based on patch by Natanael Copa <ncopa@alpinelinux.org>.
>
> Signed-off-by: Felix Janda <felix.janda@posteo.de>
> ---
> libxfs/linux.c | 29 ++++++++++++++++++++---------
> 1 file changed, 20 insertions(+), 9 deletions(-)
>
> diff --git a/libxfs/linux.c b/libxfs/linux.c
> index c532d65..e7adcf2 100644
> --- a/libxfs/linux.c
> +++ b/libxfs/linux.c
> @@ -16,11 +16,8 @@
> * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
> */
>
> -#define ustat __kernel_ustat
> #include <mntent.h>
> #include <sys/stat.h>
> -#undef ustat
> -#include <sys/ustat.h>
> #include <sys/mount.h>
> #include <sys/ioctl.h>
> #include <sys/sysinfo.h>
> @@ -51,9 +48,10 @@ static int max_block_alignment;
> int
> platform_check_ismounted(char *name, char *block, struct stat64 *s, int verbose)
> {
> - /* Pad ust; pre-2.6.28 linux copies out too much in 32bit compat mode */
> - struct ustat ust[2];
> - struct stat64 st;
> + FILE *f;
> + struct stat64 st, mst;
> + struct mntent *mnt;
> + char mounts[MAXPATHLEN];
>
> if (!s) {
> if (stat64(block, &st) < 0)
> @@ -63,14 +61,27 @@ platform_check_ismounted(char *name, char *block, struct stat64 *s, int verbose)
> s = &st;
> }
>
> - if (ustat(s->st_rdev, ust) >= 0) {
> + strcpy(mounts, (!access(PROC_MOUNTED, R_OK)) ? PROC_MOUNTED : MOUNTED);
> + if ((f = setmntent(mounts, "r")) == NULL) {
> + fprintf(stderr,
> + _("%s: %s possibly contains a mounted filesystem\n"),
> + progname, name);
> + return 1;
> + }
> + while ((mnt = getmntent(f)) != NULL) {
> + if (stat64(mnt->mnt_dir, &mst) < 0)
> + continue;
> + if (mst.st_dev != s->st_rdev)
> + continue;
> +
> if (verbose)
> fprintf(stderr,
> _("%s: %s contains a mounted filesystem\n"),
> progname, name);
> - return 1;
> + break;
> }
> - return 0;
> + endmntent(f);
> + return mnt == NULL;
> }
>
> int
>
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
* Re: [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat
2016-01-12 19:59 ` [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat Felix Janda
` (2 preceding siblings ...)
2016-09-04 1:23 ` Eric Sandeen
@ 2016-09-08 0:00 ` Dave Chinner
3 siblings, 0 replies; 31+ messages in thread
From: Dave Chinner @ 2016-09-08 0:00 UTC (permalink / raw)
To: Felix Janda; +Cc: xfs
On Tue, Jan 12, 2016 at 08:59:45PM +0100, Felix Janda wrote:
> ustat has been used to check whether a device file is mounted.
> The function is deprecated and not supported by uclibc and musl.
> Now do the check using the *mntent functions.
>
> Based on patch by Natanael Copa <ncopa@alpinelinux.org>.
>
> Signed-off-by: Felix Janda <felix.janda@posteo.de>
So, nobody has bothered to actually test this patch...
$ sudo mkfs.xfs -f -m rmapbt=1 -i sparse=1 -b size=1k /dev/sdc
specified blocksize 1024 is less than device physical sector size 4096
switching to logical sector size 512
Usage: mkfs.xfs
/* blocksize */ [-b log=n|size=num]
/* metadata */ [-m crc=0|1,finobt=0|1,uuid=xxx,rmapbt=0|1]
....
$ sudo xfs_db /dev/sdc
fatal error -- couldn't initialize XFS library
$
And so on. Basic sanity testing fails.
> @@ -63,14 +61,27 @@ platform_check_ismounted(char *name, char *block, struct stat64 *s, int verbose)
> s = &st;
> }
>
> - if (ustat(s->st_rdev, ust) >= 0) {
> + strcpy(mounts, (!access(PROC_MOUNTED, R_OK)) ? PROC_MOUNTED : MOUNTED);
> + if ((f = setmntent(mounts, "r")) == NULL) {
> + fprintf(stderr,
> + _("%s: %s possibly contains a mounted filesystem\n"),
> + progname, name);
> + return 1;
> + }
> + while ((mnt = getmntent(f)) != NULL) {
> + if (stat64(mnt->mnt_dir, &mst) < 0)
> + continue;
> + if (mst.st_dev != s->st_rdev)
> + continue;
> +
> if (verbose)
> fprintf(stderr,
> _("%s: %s contains a mounted filesystem\n"),
> progname, name);
> - return 1;
> + break;
> }
> - return 0;
> + endmntent(f);
> + return mnt == NULL;
Because that return statement has the wrong logic. It should be:
+ return mnt != NULL;
to return the correct values.
In future, please do more than a compile test on your patches before
sending them to the list for review, no matter how simple and
obviously correct you think they are!
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 31+ messages in thread
end of thread, other threads:[~2016-09-08 0:01 UTC | newest]
Thread overview: 31+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
[not found] <cover.1452627740.git.felix.janda@posteo.de>
2016-01-12 19:59 ` [PATCH 1/6] Move from __uint*_t types to uint*_t and likewise for __int*_t Felix Janda
2016-01-12 21:24 ` Dave Chinner
2016-01-12 21:46 ` Felix Janda
2016-01-12 22:02 ` Dave Chinner
2016-01-13 7:48 ` Christoph Hellwig
2016-01-20 0:46 ` Dave Chinner
2016-01-12 19:59 ` [PATCH 2/6] libxfs/linux.c: Replace use of ustat by stat Felix Janda
2016-01-12 21:24 ` Dave Chinner
2016-01-12 21:33 ` Felix Janda
2016-01-13 7:55 ` Christoph Hellwig
2016-01-13 17:42 ` Felix Janda
2016-01-14 10:20 ` Christoph Hellwig
2016-01-14 19:07 ` Felix Janda
2016-06-18 14:53 ` Felix Janda
2016-06-22 12:59 ` Christoph Hellwig
2016-09-04 1:23 ` Eric Sandeen
2016-09-08 0:00 ` Dave Chinner
2016-01-12 19:59 ` [PATCH 3/6] fsr/xfs_fsr.c: Include <paths.h> for _PATH_MOUNTED Felix Janda
2016-01-13 7:55 ` Christoph Hellwig
2016-01-12 20:00 ` [PATCH 4/6] linux.h: Use off64_t instead of loff_t Felix Janda
2016-01-13 7:55 ` Christoph Hellwig
2016-01-12 20:00 ` [PATCH 5/6] include/linux.h: Include <stdio.h> for fprintf and stderr Felix Janda
2016-01-13 7:55 ` Christoph Hellwig
2016-01-12 20:00 ` [PATCH 6/6] Add configure check for members of dirent for use in io/readdir.c Felix Janda
2016-01-12 21:30 ` Dave Chinner
2016-01-12 21:37 ` Felix Janda
2016-01-12 22:37 ` Dave Chinner
2016-01-13 7:58 ` Christoph Hellwig
2016-01-13 17:09 ` Felix Janda
2016-01-14 10:17 ` Christoph Hellwig
2016-01-14 19:06 ` Felix Janda
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.