summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
8c0fc54)
Integer types such as __uint32_t are non-standard and not supported
by some C libraries such as musl. This commit replaces them with
standard types such as uint32_t and includes stdint.h header where
necessary.
The following command was used to do the changing of types:
sed -r -i 's/__(u?int[0-9]{2}_t)/\1/g' src/*.c ltp/*.c
Signed-off-by: Rostislav Skudnov <rostislav@tuxera.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Eryu Guan <eguan@redhat.com>
pathname_t f;
int fd;
struct xfs_flock64 fl;
pathname_t f;
int fd;
struct xfs_flock64 fl;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
return;
}
inode_info(st, sizeof(st), &stb, v);
return;
}
inode_info(st, sizeof(st), &stb, v);
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
fl.l_whence = SEEK_SET;
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
fl.l_whence = SEEK_SET;
void
do_aio_rw(int opno, long r, int flags)
{
void
do_aio_rw(int opno, long r, int flags)
{
char *buf;
struct dioattr diob;
int e;
pathname_t f;
int fd;
size_t len;
char *buf;
struct dioattr diob;
int e;
pathname_t f;
int fd;
size_t len;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
dio_env = getenv("XFS_DIO_MIN");
if (dio_env)
diob.d_mem = diob.d_miniosz = atoi(dio_env);
dio_env = getenv("XFS_DIO_MIN");
if (dio_env)
diob.d_mem = diob.d_miniosz = atoi(dio_env);
- align = (__int64_t)diob.d_miniosz;
- lr = ((__int64_t)random() << 32) + random();
+ align = (int64_t)diob.d_miniosz;
+ lr = ((int64_t)random() << 32) + random();
len = (random() % FILELEN_MAX) + 1;
len -= (len % align);
if (len <= 0)
len = (random() % FILELEN_MAX) + 1;
len -= (len % align);
if (len <= 0)
__u64 last;
int nent;
xfs_bstat_t *t;
__u64 last;
int nent;
xfs_bstat_t *t;
xfs_fsop_bulkreq_t bsr;
last = 0;
xfs_fsop_bulkreq_t bsr;
last = 0;
if (len > stat1.st_size)
len = stat1.st_size;
if (len > stat1.st_size)
len = stat1.st_size;
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
if (stat1.st_size == len)
off1 = 0;
else
if (stat1.st_size == len)
off1 = 0;
else
* until we find one that doesn't overlap the source range.
*/
do {
* until we find one that doesn't overlap the source range.
*/
do {
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off2 = (off64_t)(lr % MIN(stat2.st_size + (1024 * 1024), MAXFSIZE));
off2 %= maxfsize;
off2 &= ~(stat2.st_blksize - 1);
off2 = (off64_t)(lr % MIN(stat2.st_size + (1024 * 1024), MAXFSIZE));
off2 %= maxfsize;
off2 &= ~(stat2.st_blksize - 1);
len = stat[0].st_size / 2;
/* Calculate offsets */
len = stat[0].st_size / 2;
/* Calculate offsets */
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
if (stat[0].st_size == len)
off[0] = 0;
else
if (stat[0].st_size == len)
off[0] = 0;
else
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
if (stat[i].st_size <= len)
off[i] = 0;
else
if (stat[i].st_size <= len)
off[i] = 0;
else
void
dread_f(int opno, long r)
{
void
dread_f(int opno, long r)
{
char *buf;
struct dioattr diob;
int e;
pathname_t f;
int fd;
size_t len;
char *buf;
struct dioattr diob;
int e;
pathname_t f;
int fd;
size_t len;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
if (dio_env)
diob.d_mem = diob.d_miniosz = atoi(dio_env);
if (dio_env)
diob.d_mem = diob.d_miniosz = atoi(dio_env);
- align = (__int64_t)diob.d_miniosz;
- lr = ((__int64_t)random() << 32) + random();
+ align = (int64_t)diob.d_miniosz;
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % stb.st_size);
off -= (off % align);
lseek64(fd, off, SEEK_SET);
off = (off64_t)(lr % stb.st_size);
off -= (off % align);
lseek64(fd, off, SEEK_SET);
void
dwrite_f(int opno, long r)
{
void
dwrite_f(int opno, long r)
{
char *buf;
struct dioattr diob;
int e;
pathname_t f;
int fd;
size_t len;
char *buf;
struct dioattr diob;
int e;
pathname_t f;
int fd;
size_t len;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
if (dio_env)
diob.d_mem = diob.d_miniosz = atoi(dio_env);
if (dio_env)
diob.d_mem = diob.d_miniosz = atoi(dio_env);
- align = (__int64_t)diob.d_miniosz;
- lr = ((__int64_t)random() << 32) + random();
+ align = (int64_t)diob.d_miniosz;
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off -= (off % align);
lseek64(fd, off, SEEK_SET);
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off -= (off % align);
lseek64(fd, off, SEEK_SET);
int e;
pathname_t f;
int fd;
int e;
pathname_t f;
int fd;
off64_t off;
off64_t len;
struct stat64 stb;
off64_t off;
off64_t len;
struct stat64 stb;
return;
}
inode_info(st, sizeof(st), &stb, v);
return;
}
inode_info(st, sizeof(st), &stb, v);
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
len = (off64_t)(random() % (1024 * 1024));
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
len = (off64_t)(random() % (1024 * 1024));
int e;
pathname_t f;
int fd;
int e;
pathname_t f;
int fd;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
fiemap->fm_flags = random() & (FIEMAP_FLAGS_COMPAT | 0x10000);
fiemap->fm_extent_count = blocks_to_map;
fiemap->fm_mapped_extents = random() & 0xffff;
fiemap->fm_start = off;
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
fiemap->fm_flags = random() & (FIEMAP_FLAGS_COMPAT | 0x10000);
fiemap->fm_extent_count = blocks_to_map;
fiemap->fm_mapped_extents = random() & 0xffff;
fiemap->fm_start = off;
- fiemap->fm_length = ((__int64_t)random() << 32) + random();
+ fiemap->fm_length = ((int64_t)random() << 32) + random();
e = ioctl(fd, FS_IOC_FIEMAP, (unsigned long)fiemap);
if (v)
e = ioctl(fd, FS_IOC_FIEMAP, (unsigned long)fiemap);
if (v)
pathname_t f;
int fd;
struct xfs_flock64 fl;
pathname_t f;
int fd;
struct xfs_flock64 fl;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
return;
}
inode_info(st, sizeof(st), &stb, v);
return;
}
inode_info(st, sizeof(st), &stb, v);
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
fl.l_whence = SEEK_SET;
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
fl.l_whence = SEEK_SET;
pathname_t f;
int fd;
size_t len;
pathname_t f;
int fd;
size_t len;
off64_t off;
int flags;
struct stat64 stb;
off64_t off;
int flags;
struct stat64 stb;
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % stb.st_size);
off &= (off64_t)(~(sysconf(_SC_PAGE_SIZE) - 1));
len = (size_t)(random() % MIN(stb.st_size - off, FILELEN_MAX)) + 1;
off = (off64_t)(lr % stb.st_size);
off &= (off64_t)(~(sysconf(_SC_PAGE_SIZE) - 1));
len = (size_t)(random() % MIN(stb.st_size - off, FILELEN_MAX)) + 1;
pathname_t f;
int fd;
size_t len;
pathname_t f;
int fd;
size_t len;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % stb.st_size);
lseek64(fd, off, SEEK_SET);
len = (random() % FILELEN_MAX) + 1;
off = (off64_t)(lr % stb.st_size);
lseek64(fd, off, SEEK_SET);
len = (random() % FILELEN_MAX) + 1;
pathname_t f;
int fd;
size_t len;
pathname_t f;
int fd;
size_t len;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % stb.st_size);
lseek64(fd, off, SEEK_SET);
len = (random() % FILELEN_MAX) + 1;
off = (off64_t)(lr % stb.st_size);
lseek64(fd, off, SEEK_SET);
len = (random() % FILELEN_MAX) + 1;
pathname_t f;
int fd;
struct xfs_flock64 fl;
pathname_t f;
int fd;
struct xfs_flock64 fl;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
return;
}
inode_info(st, sizeof(st), &stb, v);
return;
}
inode_info(st, sizeof(st), &stb, v);
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
fl.l_whence = SEEK_SET;
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
fl.l_whence = SEEK_SET;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
return;
}
inode_info(st, sizeof(st), &stb, v);
return;
}
inode_info(st, sizeof(st), &stb, v);
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
e = truncate64_path(&f, off) < 0 ? errno : 0;
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
e = truncate64_path(&f, off) < 0 ? errno : 0;
pathname_t f;
int fd;
struct xfs_flock64 fl;
pathname_t f;
int fd;
struct xfs_flock64 fl;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
return;
}
inode_info(st, sizeof(st), &stb, v);
return;
}
inode_info(st, sizeof(st), &stb, v);
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
fl.l_whence = SEEK_SET;
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
fl.l_whence = SEEK_SET;
pathname_t f;
int fd;
size_t len;
pathname_t f;
int fd;
size_t len;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
return;
}
inode_info(st, sizeof(st), &stb, v);
return;
}
inode_info(st, sizeof(st), &stb, v);
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
lseek64(fd, off, SEEK_SET);
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
lseek64(fd, off, SEEK_SET);
pathname_t f;
int fd;
size_t len;
pathname_t f;
int fd;
size_t len;
off64_t off;
struct stat64 stb;
int v;
off64_t off;
struct stat64 stb;
int v;
return;
}
inode_info(st, sizeof(st), &stb, v);
return;
}
inode_info(st, sizeof(st), &stb, v);
- lr = ((__int64_t)random() << 32) + random();
+ lr = ((int64_t)random() << 32) + random();
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
lseek64(fd, off, SEEK_SET);
off = (off64_t)(lr % MIN(stb.st_size + (1024 * 1024), MAXFSIZE));
off %= maxfsize;
lseek64(fd, off, SEEK_SET);
int tflag = 0;
int nflag = 0;
int unlinkit = 0;
int tflag = 0;
int nflag = 0;
int unlinkit = 0;
while ((c = getopt(argc, argv, "b:d:f:rtn")) != -1) {
switch (c) {
while ((c = getopt(argc, argv, "b:d:f:rtn")) != -1) {
switch (c) {
}
/* 98789 is greater than 2^16 (65536) */
}
/* 98789 is greater than 2^16 (65536) */
- if ((__uint32_t)sbuf.st_uid == 98789 || (__uint32_t)sbuf.st_gid == 98789)
+ if ((uint32_t)sbuf.st_uid == 98789 || (uint32_t)sbuf.st_gid == 98789)
return(0);
if (verbose)
fprintf(stderr, "lstat64 on %s gave uid=%d, gid=%d\n",
return(0);
if (verbose)
fprintf(stderr, "lstat64 on %s gave uid=%d, gid=%d\n",
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
int main(int argc, char **argv)
{
int main(int argc, char **argv)
{
long long sz = -1;
int error, fd;
long long sz = -1;
int error, fd;
#ifdef STDC_HEADERS
#include <signal.h>
#ifdef STDC_HEADERS
#include <signal.h>
#endif
#ifdef HAVE_STRINGS_H
#endif
#ifdef HAVE_STRINGS_H
xlog_op_header_t *op;
/* the data section must be 32 bit size aligned */
struct {
xlog_op_header_t *op;
/* 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 };
if (!count) count=1;
} magic = { XLOG_UNMOUNT_TYPE, 0, 0 };
if (!count) count=1;
#include "global.h"
char *progname;
#include "global.h"
char *progname;
-__uint64_t num_holes = 1000;
-__uint64_t curr_holes;
+uint64_t num_holes = 1000;
+uint64_t curr_holes;
int verbose_opt = 0;
char *filename;
int status_num = 100;
int wsync;
int preserve;
unsigned int blocksize;
int verbose_opt = 0;
char *filename;
int status_num = 100;
int wsync;
int preserve;
unsigned int blocksize;
#define JUMP_SIZE (128 * 1024)
#define NUMHOLES_TO_SIZE(i) (i * JUMP_SIZE)
#define JUMP_SIZE (128 * 1024)
#define NUMHOLES_TO_SIZE(i) (i * JUMP_SIZE)
int c;
int fd;
int oflags;
int c;
int fd;
int oflags;
- __uint64_t i;
- __uint64_t offset;
+ uint64_t i;
+ uint64_t offset;
int blocksize = 512;
unsigned char *buffer = NULL;
struct stat stat;
int blocksize = 512;
unsigned char *buffer = NULL;
struct stat stat;
#include "global.h"
#define power_of_2(x) ((x) && !((x) & ((x) - 1)))
#include "global.h"
#define power_of_2(x) ((x) && !((x) & ((x) - 1)))
-#define DEFAULT_FILESIZE ((__uint64_t) (256 * 1024 * 1024))
+#define DEFAULT_FILESIZE ((uint64_t) (256 * 1024 * 1024))
#define DEFAULT_BLOCKSIZE 512
#define SETBIT(ARRAY, N) ((ARRAY)[(N)/8] |= (1 << ((N)%8)))
#define DEFAULT_BLOCKSIZE 512
#define SETBIT(ARRAY, N) ((ARRAY)[(N)/8] |= (1 << ((N)%8)))
/* Bit-vector array showing which blocks have been written */
static unsigned char *valid;
/* Bit-vector array showing which blocks have been written */
static unsigned char *valid;
-static __uint64_t filesize;
-static __uint64_t fileoffset;
+static uint64_t filesize;
+static uint64_t fileoffset;
static unsigned int blocksize;
static int count;
static unsigned int blocksize;
static int count;
fprintf(stderr, "\tdefault count is %d block-sized writes\n",
(int) (DEFAULT_FILESIZE / DEFAULT_BLOCKSIZE));
fprintf(stderr, "\tdefault write_offset is %" PRIu64 " bytes\n",
fprintf(stderr, "\tdefault count is %d block-sized writes\n",
(int) (DEFAULT_FILESIZE / DEFAULT_BLOCKSIZE));
fprintf(stderr, "\tdefault write_offset is %" PRIu64 " bytes\n",
-dumpblock(int *buffer, __uint64_t offset, int blocksize)
+dumpblock(int *buffer, uint64_t offset, int blocksize)
static void
writeblks(char *fname, int fd, size_t alignment)
{
static void
writeblks(char *fname, int fd, size_t alignment)
{
char *buffer = NULL;
int block;
int ret;
char *buffer = NULL;
int block;
int ret;
- offset = (__uint64_t) block * blocksize;
+ offset = (uint64_t) block * blocksize;
if (alloconly) {
if (test) continue;
if (alloconly) {
if (test) continue;
* into it. We'll verify this when we read
* it back in again.
*/
* into it. We'll verify this when we read
* it back in again.
*/
- *(__uint64_t *) buffer = fileoffset + offset;
- *(__uint64_t *) (buffer + 256) = fileoffset + offset;
+ *(uint64_t *) buffer = fileoffset + offset;
+ *(uint64_t *) (buffer + 256) = fileoffset + offset;
if (write(fd, buffer, blocksize) < blocksize) {
perror("write");
if (write(fd, buffer, blocksize) < blocksize) {
perror("write");
static int
readblks(int fd, size_t alignment)
{
static int
readblks(int fd, size_t alignment)
{
char *buffer, *tmp;
unsigned int xfer, block, i;
int err=0;
char *buffer, *tmp;
unsigned int xfer, block, i;
int err=0;
}
tmp = buffer;
for (i = 0; i < READ_XFER; i++) {
}
tmp = buffer;
for (i = 0; i < READ_XFER; i++) {
- __uint64_t want;
- __uint64_t first;
- __uint64_t second;
+ uint64_t want;
+ uint64_t first;
+ uint64_t second;
if (verbose && ((block % 100) == 0)) {
printf("+");
if (verbose && ((block % 100) == 0)) {
printf("+");
}
want = BITVAL(valid, block) ? offset : 0;
}
want = BITVAL(valid, block) ? offset : 0;
- first = *(__uint64_t *) tmp;
- second = *(__uint64_t *) (tmp + 256);
+ first = *(uint64_t *) tmp;
+ second = *(uint64_t *) (tmp + 256);
if (first != want || second != want) {
printf("mismatched data at offset=0x%" PRIx64
", expected 0x%" PRIx64
if (first != want || second != want) {
printf("mismatched data at offset=0x%" PRIx64
", expected 0x%" PRIx64