means default for reads, 8k for writes and trims.
**bs=,8k,**
- means default for reads, 8k for writes, and default for writes.
+ means default for reads, 8k for writes, and default for trims.
.. option:: blocksize_range=irange[,irange][,irange], bsrange=irange[,irange][,irange]
contents to one or more separate threads. If using this offload option, even
sync I/O engines can benefit from using an :option:`iodepth` setting higher
than 1, as it allows them to have I/O in flight while verifies are running.
+ Defaults to 0 async threads, i.e. verification is not asynchronous.
.. option:: verify_async_cpus=str
<type> is "local" for a local run, "sock" for a client/server socket
connection, and "ip" (192.168.0.1, for instance) for a networked
- client/server connection.
+ client/server connection. Defaults to true.
.. option:: verify_state_load=bool
LDFLAGS += -rdynamic
endif
ifeq ($(CONFIG_TARGET_OS), Android)
- SOURCE += diskutil.c fifo.c blktrace.c trim.c profiles/tiobench.c \
+ SOURCE += diskutil.c fifo.c blktrace.c cgroup.c trim.c profiles/tiobench.c \
oslib/linux-dev-lookup.c
LIBS += -ldl
LDFLAGS += -rdynamic
#include "flist.h"
#include "fio.h"
+#include "blktrace.h"
#include "blktrace_api.h"
#include "oslib/linux-dev-lookup.h"
--- /dev/null
+#ifndef FIO_BLKTRACE_H
+#define FIO_BLKTRACE_H
+
+#ifdef FIO_HAVE_BLKTRACE
+
+int is_blktrace(const char *, int *);
+int load_blktrace(struct thread_data *, const char *, int);
+
+#else
+
+static inline int is_blktrace(const char *fname, int *need_swap)
+{
+ return 0;
+}
+
+static inline int load_blktrace(struct thread_data *td, const char *fname,
+ int need_swap)
+{
+ return 1;
+}
+
+#endif
+#endif
exit 1
}
+# Print result for each configuration test
+print_config() {
+ printf "%-30s%s\n" "$1" "$2"
+}
+
# Default CFLAGS
CFLAGS="-D_GNU_SOURCE -include config-host.h"
BUILD_CFLAGS=""
fi
-echo "Operating system $targetos"
-echo "CPU $cpu"
-echo "Big endian $bigendian"
-echo "Compiler $cc"
-echo "Cross compile $cross_compile"
+print_config "Operating system" "$targetos"
+print_config "CPU" "$cpu"
+print_config "Big endian" "$bigendian"
+print_config "Compiler" "$cc"
+print_config "Cross compile" "$cross_compile"
echo
##########################################
else
build_static="no"
fi
-echo "Static build $build_static"
+print_config "Static build" "$build_static"
##########################################
# check for wordsize
else
fatal "Unknown wordsize"
fi
-echo "Wordsize $wordsize"
+print_config "Wordsize" "$wordsize"
##########################################
# zlib probe
zlib=yes
LIBS="-lz $LIBS"
fi
-echo "zlib $zlib"
+print_config "zlib" "$zlib"
##########################################
# linux-aio probe
libaio=no
fi
fi
-echo "Linux AIO support $libaio"
+print_config "Linux AIO support" "$libaio"
##########################################
# posix aio probe
posix_aio_lrt="yes"
LIBS="-lrt $LIBS"
fi
-echo "POSIX AIO support $posix_aio"
-echo "POSIX AIO support needs -lrt $posix_aio_lrt"
+print_config "POSIX AIO support" "$posix_aio"
+print_config "POSIX AIO support needs -lrt" "$posix_aio_lrt"
##########################################
# posix aio fsync probe
posix_aio_fsync=yes
fi
fi
-echo "POSIX AIO fsync $posix_aio_fsync"
+print_config "POSIX AIO fsync" "$posix_aio_fsync"
##########################################
# POSIX pshared attribute probe
if compile_prog "" "$LIBS" "posix_pshared" ; then
posix_pshared=yes
fi
-echo "POSIX pshared support $posix_pshared"
+print_config "POSIX pshared support" "$posix_pshared"
##########################################
# solaris aio probe
solaris_aio=yes
LIBS="-laio $LIBS"
fi
-echo "Solaris AIO support $solaris_aio"
+print_config "Solaris AIO support" "$solaris_aio"
##########################################
# __sync_fetch_and_add test
if compile_prog "" "" "__sync_fetch_and_add()" ; then
sfaa="yes"
fi
-echo "__sync_fetch_and_add $sfaa"
+print_config "__sync_fetch_and_add" "$sfaa"
##########################################
# libverbs probe
libverbs="yes"
LIBS="-libverbs $LIBS"
fi
-echo "libverbs $libverbs"
+print_config "libverbs" "$libverbs"
##########################################
# rdmacm probe
rdmacm="yes"
LIBS="-lrdmacm $LIBS"
fi
-echo "rdmacm $rdmacm"
+print_config "rdmacm" "$rdmacm"
##########################################
# Linux fallocate probe
if compile_prog "" "" "linux_fallocate"; then
linux_fallocate="yes"
fi
-echo "Linux fallocate $linux_fallocate"
+print_config "Linux fallocate" "$linux_fallocate"
##########################################
# POSIX fadvise probe
if compile_prog "" "" "posix_fadvise"; then
posix_fadvise="yes"
fi
-echo "POSIX fadvise $posix_fadvise"
+print_config "POSIX fadvise" "$posix_fadvise"
##########################################
# POSIX fallocate probe
if compile_prog "" "" "posix_fallocate"; then
posix_fallocate="yes"
fi
-echo "POSIX fallocate $posix_fallocate"
+print_config "POSIX fallocate" "$posix_fallocate"
##########################################
# sched_set/getaffinity 2 or 3 argument test
linux_2arg_affinity="yes"
fi
fi
-echo "sched_setaffinity(3 arg) $linux_3arg_affinity"
-echo "sched_setaffinity(2 arg) $linux_2arg_affinity"
+print_config "sched_setaffinity(3 arg)" "$linux_3arg_affinity"
+print_config "sched_setaffinity(2 arg)" "$linux_2arg_affinity"
##########################################
# clock_gettime probe
clock_gettime="yes"
LIBS="-lrt $LIBS"
fi
-echo "clock_gettime $clock_gettime"
+print_config "clock_gettime" "$clock_gettime"
##########################################
# CLOCK_MONOTONIC probe
clock_monotonic="yes"
fi
fi
-echo "CLOCK_MONOTONIC $clock_monotonic"
+print_config "CLOCK_MONOTONIC" "$clock_monotonic"
##########################################
# CLOCK_MONOTONIC_RAW probe
clock_monotonic_raw="yes"
fi
fi
-echo "CLOCK_MONOTONIC_RAW $clock_monotonic_raw"
+print_config "CLOCK_MONOTONIC_RAW" "$clock_monotonic_raw"
##########################################
# CLOCK_MONOTONIC_PRECISE probe
clock_monotonic_precise="yes"
fi
fi
-echo "CLOCK_MONOTONIC_PRECISE $clock_monotonic_precise"
+print_config "CLOCK_MONOTONIC_PRECISE" "$clock_monotonic_precise"
##########################################
# clockid_t probe
if compile_prog "" "$LIBS" "clockid_t"; then
clockid_t="yes"
fi
-echo "clockid_t $clockid_t"
+print_config "clockid_t" "$clockid_t"
##########################################
# gettimeofday() probe
if compile_prog "" "" "gettimeofday"; then
gettimeofday="yes"
fi
-echo "gettimeofday $gettimeofday"
+print_config "gettimeofday" "$gettimeofday"
##########################################
# fdatasync() probe
if compile_prog "" "" "fdatasync"; then
fdatasync="yes"
fi
-echo "fdatasync $fdatasync"
+print_config "fdatasync" "$fdatasync"
##########################################
# sync_file_range() probe
if compile_prog "" "" "sync_file_range"; then
sync_file_range="yes"
fi
-echo "sync_file_range $sync_file_range"
+print_config "sync_file_range" "$sync_file_range"
##########################################
# ext4 move extent probe
# work. Takes a while to bubble back.
ext4_me="yes"
fi
-echo "EXT4 move extent $ext4_me"
+print_config "EXT4 move extent" "$ext4_me"
##########################################
# splice probe
if compile_prog "" "" "linux splice"; then
linux_splice="yes"
fi
-echo "Linux splice(2) $linux_splice"
+print_config "Linux splice(2)" "$linux_splice"
##########################################
# GUASI probe
if compile_prog "" "" "guasi"; then
guasi="yes"
fi
-echo "GUASI $guasi"
+print_config "GUASI" "$guasi"
##########################################
# fusion-aw probe
LIBS="-L/usr/lib/fio -L/usr/lib/nvm -lnvm-primitives -ldl -lpthread $LIBS"
fusion_aw="yes"
fi
-echo "Fusion-io atomic engine $fusion_aw"
+print_config "Fusion-io atomic engine" "$fusion_aw"
##########################################
# libnuma probe
libnuma="yes"
LIBS="-lnuma $LIBS"
fi
-echo "libnuma $libnuma"
+print_config "libnuma" "$libnuma"
##########################################
# libnuma 2.x version API, initialize with "no" only if $libnuma is set to "yes"
if compile_prog "" "" "libnuma api"; then
libnuma_v2="yes"
fi
-echo "libnuma v2 $libnuma_v2"
+print_config "libnuma v2" "$libnuma_v2"
fi
##########################################
if compile_prog "" "" "strsep"; then
strsep="yes"
fi
-echo "strsep $strsep"
+print_config "strsep" "$strsep"
##########################################
# strcasestr() probe
if compile_prog "" "" "strcasestr"; then
strcasestr="yes"
fi
-echo "strcasestr $strcasestr"
+print_config "strcasestr" "$strcasestr"
##########################################
# strlcat() probe
if compile_prog "" "" "strlcat"; then
strlcat="yes"
fi
-echo "strlcat $strlcat"
+print_config "strlcat" "$strlcat"
##########################################
# getopt_long_only() probe
if compile_prog "" "" "getopt_long_only"; then
getopt_long_only="yes"
fi
-echo "getopt_long_only() $getopt_long_only"
+print_config "getopt_long_only()" "$getopt_long_only"
##########################################
# inet_aton() probe
if compile_prog "" "" "inet_aton"; then
inet_aton="yes"
fi
-echo "inet_aton $inet_aton"
+print_config "inet_aton" "$inet_aton"
##########################################
# socklen_t probe
if compile_prog "" "" "socklen_t"; then
socklen_t="yes"
fi
-echo "socklen_t $socklen_t"
+print_config "socklen_t" "$socklen_t"
##########################################
# Whether or not __thread is supported for TLS
if compile_prog "" "" "__thread"; then
tls_thread="yes"
fi
-echo "__thread $tls_thread"
+print_config "__thread" "$tls_thread"
##########################################
# Check if we have required gtk/glib support for gfio
fi
if test "$gfio_check" = "yes" ; then
- echo "gtk 2.18 or higher $gfio"
+ print_config "gtk 2.18 or higher" "$gfio"
fi
##########################################
if compile_prog "" "" "RUSAGE_THREAD"; then
rusage_thread="yes"
fi
-echo "RUSAGE_THREAD $rusage_thread"
+print_config "RUSAGE_THREAD" "$rusage_thread"
##########################################
# Check whether we have SCHED_IDLE
if compile_prog "" "" "SCHED_IDLE"; then
sched_idle="yes"
fi
-echo "SCHED_IDLE $sched_idle"
+print_config "SCHED_IDLE" "$sched_idle"
##########################################
# Check whether we have TCP_NODELAY
if compile_prog "" "" "TCP_NODELAY"; then
tcp_nodelay="yes"
fi
-echo "TCP_NODELAY $tcp_nodelay"
+print_config "TCP_NODELAY" "$tcp_nodelay"
##########################################
# Check whether we have SO_SNDBUF
if compile_prog "" "" "SO_SNDBUF"; then
window_size="yes"
fi
-echo "Net engine window_size $window_size"
+print_config "Net engine window_size" "$window_size"
##########################################
# Check whether we have TCP_MAXSEG
if compile_prog "" "" "TCP_MAXSEG"; then
mss="yes"
fi
-echo "TCP_MAXSEG $mss"
+print_config "TCP_MAXSEG" "$mss"
##########################################
# Check whether we have RLIMIT_MEMLOCK
if compile_prog "" "" "RLIMIT_MEMLOCK"; then
rlimit_memlock="yes"
fi
-echo "RLIMIT_MEMLOCK $rlimit_memlock"
+print_config "RLIMIT_MEMLOCK" "$rlimit_memlock"
##########################################
# Check whether we have pwritev/preadv
if compile_prog "" "" "pwritev"; then
pwritev="yes"
fi
-echo "pwritev/preadv $pwritev"
+print_config "pwritev/preadv" "$pwritev"
##########################################
# Check whether we have pwritev2/preadv2
if compile_prog "" "" "pwritev2"; then
pwritev2="yes"
fi
-echo "pwritev2/preadv2 $pwritev2"
+print_config "pwritev2/preadv2" "$pwritev2"
##########################################
# Check whether we have the required functions for ipv6
if compile_prog "" "" "ipv6"; then
ipv6="yes"
fi
-echo "IPv6 helpers $ipv6"
+print_config "IPv6 helpers" "$ipv6"
##########################################
# check for rbd
LIBS="-lrbd -lrados $LIBS"
rbd="yes"
fi
-echo "Rados Block Device engine $rbd"
+print_config "Rados Block Device engine" "$rbd"
##########################################
# check for rbd_poll
if compile_prog "" "-lrbd -lrados" "rbd"; then
rbd_poll="yes"
fi
-echo "rbd_poll $rbd_poll"
+print_config "rbd_poll" "$rbd_poll"
fi
##########################################
if compile_prog "" "-lrbd -lrados" "rbd"; then
rbd_inval="yes"
fi
-echo "rbd_invalidate_cache $rbd_inval"
+print_config "rbd_invalidate_cache" "$rbd_inval"
fi
##########################################
LIBS="-lblkin $LIBS"
rbd_blkin="yes"
fi
-echo "rbd blkin tracing $rbd_blkin"
+print_config "rbd blkin tracing" "$rbd_blkin"
##########################################
# Check whether we have setvbuf
if compile_prog "" "" "setvbuf"; then
setvbuf="yes"
fi
-echo "setvbuf $setvbuf"
+print_config "setvbuf" "$setvbuf"
##########################################
# check for gfapi
LIBS="-lgfapi -lglusterfs $LIBS"
gfapi="yes"
fi
- echo "Gluster API engine $gfapi"
+print_config "Gluster API engine" "$gfapi"
##########################################
# check for gfapi fadvise support, initialize with "no" only if $gfapi is set to "yes"
if compile_prog "" "-lgfapi -lglusterfs" "gfapi"; then
gf_fadvise="yes"
fi
-echo "Gluster API use fadvise $gf_fadvise"
+print_config "Gluster API use fadvise" "$gf_fadvise"
fi
##########################################
if compile_prog "" "-lgfapi -lglusterfs" "gf trim"; then
gf_trim="yes"
fi
-echo "Gluster API trim support $gf_trim"
+print_config "Gluster API trim support" "$gf_trim"
fi
##########################################
EOF
if compile_prog "" "" "s390_z196_facilities"; then
$TMPE
- if [[ $? -eq 0 ]]; then
+ if [ $? -eq 0 ]; then
s390_z196_facilities="yes"
fi
fi
-echo "s390_z196_facilities $s390_z196_facilities"
+print_config "s390_z196_facilities" "$s390_z196_facilities"
##########################################
# Check if we have required environment variables configured for libhdfs
FIO_HDFS_CPU="amd64"
fi
fi
-echo "HDFS engine $libhdfs"
+print_config "HDFS engine" "$libhdfs"
##########################################
# Check whether we have MTD
if compile_prog "" "" "mtd"; then
mtd="yes"
fi
-echo "MTD $mtd"
+print_config "MTD" "$mtd"
##########################################
# Check whether we have libpmem
libpmem="yes"
LIBS="-lpmem $LIBS"
fi
-echo "libpmem $libpmem"
+print_config "libpmem" "$libpmem"
##########################################
# Check whether we have libpmemblk
LIBS="-lpmemblk $LIBS"
fi
fi
-echo "libpmemblk $libpmemblk"
+print_config "libpmemblk" "$libpmemblk"
# Choose the ioengines
if test "$libpmem" = "yes" && test "$disable_pmem" = "no"; then
##########################################
# Report whether pmemblk engine is enabled
-echo "NVML pmemblk engine $pmemblk"
+print_config "NVML pmemblk engine" "$pmemblk"
##########################################
# Report whether dev-dax engine is enabled
-echo "NVML dev-dax engine $devdax"
+print_config "NVML dev-dax engine" "$devdax"
##########################################
# Check if we have lex/yacc available
fi
fi
-echo "lex/yacc for arithmetic $arith"
+print_config "lex/yacc for arithmetic" "$arith"
##########################################
# Check whether we have setmntent/getmntent
if compile_prog "" "" "getmntent"; then
getmntent="yes"
fi
-echo "getmntent $getmntent"
+print_config "getmntent" "$getmntent"
##########################################
# Check whether we have getmntinfo
if compile_prog "-Werror" "" "getmntinfo"; then
getmntinfo="yes"
fi
-echo "getmntinfo $getmntinfo"
+print_config "getmntinfo" "$getmntinfo"
# getmntinfo(3) for NetBSD.
if test "$getmntinfo_statvfs" != "yes" ; then
# Skip the test if the one with statfs arg is detected.
if test "$getmntinfo" != "yes" && compile_prog "-Werror" "" "getmntinfo_statvfs"; then
getmntinfo_statvfs="yes"
- echo "getmntinfo_statvfs $getmntinfo_statvfs"
+ print_config "getmntinfo_statvfs" "$getmntinfo_statvfs"
fi
##########################################
cat > $TMPC << EOF
#include <assert.h>
#include <stdlib.h>
-#undef offsetof
-#ifdef __compiler_offsetof
-#define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
-#else
-#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
-#endif
-
-#define container_of(ptr, type, member) ({ \
- const typeof( ((type *)0)->member ) *__mptr = (ptr); \
- (type *)( (char *)__mptr - offsetof(type,member) );})
+#include <stddef.h>
struct foo {
int a, b;
if compile_prog "" "" "static_assert"; then
static_assert="yes"
fi
-echo "Static Assert $static_assert"
+print_config "Static Assert" "$static_assert"
##########################################
# Check whether we have bool / stdbool.h
if compile_prog "" "" "bool"; then
have_bool="yes"
fi
-echo "bool $have_bool"
+print_config "bool" "$have_bool"
##########################################
# check march=armv8-a+crc+crypto
CFLAGS="$CFLAGS -march=armv8-a+crc+crypto -DARCH_HAVE_CRC_CRYPTO"
fi
fi
-echo "march_armv8_a_crc_crypto $march_armv8_a_crc_crypto"
+print_config "march_armv8_a_crc_crypto" "$march_armv8_a_crc_crypto"
##########################################
# cuda probe
cuda="yes"
LIBS="-lcuda $LIBS"
fi
-echo "cuda $cuda"
+print_config "cuda" "$cuda"
#############################################################################
total_size = -1ULL;
else {
if (o->size_percent) {
- f->io_size = (f->io_size * o->size_percent) / 100;
+ uint64_t file_size;
+
+ file_size = f->io_size + f->file_offset;
+ f->io_size = (file_size *
+ o->size_percent) / 100;
+ if (f->io_size > (file_size - f->file_offset))
+ f->io_size = file_size - f->file_offset;
+
f->io_size -= (f->io_size % td_min_bs(td));
}
total_size += f->io_size;
-.TH fio 1 "March 2017" "User Manual"
+.TH fio 1 "May 2017" "User Manual"
.SH NAME
fio \- flexible I/O tester
.SH SYNOPSIS
bs=8k,32k means 8k for reads, 32k for writes and trims
bs=8k,32k, means 8k for reads, 32k for writes, and default for trims
bs=,8k means default for reads, 8k for writes and trims
-bs=,8k, means default for reads, 8k for writes, and default for writes
+bs=,8k, means default for reads, 8k for writes, and default for trims
.fi
.TP
.BI blocksize_range \fR=\fPirange[,irange][,irange] "\fR,\fB bsrange" \fR=\fPirange[,irange][,irange]
.br
These are typically located under /usr/share/doc/fio.
-\fBHOWTO\fR: http://git.kernel.dk/?p=fio.git;a=blob_plain;f=HOWTO
+\fBHOWTO\fR: http://git.kernel.dk/cgit/fio/plain/HOWTO
.br
-\fBREADME\fR: http://git.kernel.dk/?p=fio.git;a=blob_plain;f=README
+\fBREADME\fR: http://git.kernel.dk/cgit/fio/plain/README
.br
unsigned int thread_number;
unsigned int subjob_number;
unsigned int groupid;
- struct thread_stat ts;
+ struct thread_stat ts __attribute__ ((aligned));
int client_type;
*/
extern void reset_all_stats(struct thread_data *);
-/*
- * blktrace support
- */
-#ifdef FIO_HAVE_BLKTRACE
-extern int is_blktrace(const char *, int *);
-extern int load_blktrace(struct thread_data *, const char *, int);
-#endif
-
extern int io_queue_event(struct thread_data *td, struct io_u *io_u, int *ret,
enum fio_ddir ddir, uint64_t *bytes_issued, int from_verify,
struct timeval *comp_time);
#define _LINUX_FLIST_H
#include <stdlib.h>
-
-#undef offsetof
-#ifdef __compiler_offsetof
-#define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
-#else
-#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
-#endif
+#include <stddef.h>
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
bool use64;
if (td->o.random_generator == FIO_RAND_GEN_TAUSWORTHE64)
- use64 = 1;
+ use64 = true;
else
- use64 = 0;
+ use64 = false;
init_rand_seed(&td->verify_state, td->rand_seeds[FIO_RAND_VER_OFF],
use64);
}
if (td->o.random_generator == FIO_RAND_GEN_TAUSWORTHE64)
- use64 = 1;
+ use64 = true;
else
- use64 = 0;
+ use64 = false;
td_fill_rand_seeds_internal(td, use64);
unsigned long seed;
unsigned int i;
- if (!td->o.rand_repeatable && !fio_option_is_set(&td->o, rand_seed))
- return init_random_state(td, td->rand_seeds, sizeof(td->rand_seeds));
+ if (!td->o.rand_repeatable && !fio_option_is_set(&td->o, rand_seed)) {
+ int ret = init_random_seeds(td->rand_seeds, sizeof(td->rand_seeds));
+ if (!ret)
+ td_fill_rand_seeds(td);
+ return ret;
+ }
seed = td->o.rand_seed;
for (i = 0; i < 4; i++)
prev_group_jobs++;
if (setup_random_seeds(td)) {
- td_verror(td, errno, "init_random_state");
+ td_verror(td, errno, "setup_random_seeds");
goto err;
}
#include "trim.h"
#include "filelock.h"
#include "smalloc.h"
+#include "blktrace.h"
static int iolog_flush(struct io_log *log);
#include <stdlib.h>
#include "output_buffer.h"
-#include "../log.h"
#include "../minmax.h"
#define BUF_INC 1024
void buf_output_free(struct buf_output *out)
{
free(out->buf);
+ buf_output_init(out);
}
size_t buf_output_add(struct buf_output *out, const char *buf, size_t len)
out->buflen += len;
return len;
}
-
-size_t buf_output_flush(struct buf_output *out)
-{
- size_t ret = 0;
-
- if (out->buflen) {
- ret = log_info_buf(out->buf, out->buflen);
- memset(out->buf, 0, out->max_buflen);
- out->buflen = 0;
- }
-
- return ret;
-}
void buf_output_init(struct buf_output *out);
void buf_output_free(struct buf_output *out);
size_t buf_output_add(struct buf_output *out, const char *buf, size_t len);
-size_t buf_output_flush(struct buf_output *out);
#endif
* can run into problems on archs that fault on unaligned fp
* access (ARM).
*/
+ compiletime_assert((offsetof(struct thread_data, ts) % sizeof(void *)) == 0, "ts");
compiletime_assert((offsetof(struct thread_stat, percentile_list) % 8) == 0, "stat percentile_list");
compiletime_assert((offsetof(struct thread_stat, total_run_time) % 8) == 0, "total_run_time");
compiletime_assert((offsetof(struct thread_stat, total_err_count) % 8) == 0, "total_err_count");
compiletime_assert((offsetof(struct thread_stat, latency_percentile) % 8) == 0, "stat latency_percentile");
+ compiletime_assert((offsetof(struct thread_data, ts.clat_stat) % 8) == 0, "ts.clat_stat");
compiletime_assert((offsetof(struct thread_options_pack, zipf_theta) % 8) == 0, "zipf_theta");
compiletime_assert((offsetof(struct thread_options_pack, pareto_h) % 8) == 0, "pareto_h");
compiletime_assert((offsetof(struct thread_options_pack, percentile_list) % 8) == 0, "percentile_list");
compiletime_assert((offsetof(struct thread_options_pack, latency_percentile) % 8) == 0, "latency_percentile");
+ compiletime_assert((offsetof(struct jobs_eta, m_rate) % 8) == 0, "m_rate");
err = endian_check();
if (err) {
#include "fio.h"
+#define LOG_START_SZ 512
+
size_t log_info_buf(const char *buf, size_t len)
{
+ /*
+ * buf could be NULL (not just "").
+ */
+ if (!buf)
+ return 0;
+
if (is_backend) {
size_t ret = fio_server_text_output(FIO_LOG_INFO, buf, len);
if (ret != -1)
return fwrite(buf, len, 1, f_out);
}
-size_t log_valist(const char *str, va_list args)
+static size_t valist_to_buf(char **buffer, const char *fmt, va_list src_args)
{
- char buffer[1024];
+ size_t len, cur = LOG_START_SZ;
+ va_list args;
+
+ do {
+ *buffer = calloc(1, cur);
+
+ va_copy(args, src_args);
+ len = vsnprintf(*buffer, cur, fmt, args);
+ va_end(args);
+
+ if (len < cur)
+ break;
+
+ cur = len + 1;
+ free(*buffer);
+ } while (1);
+
+ return len;
+}
+
+size_t log_valist(const char *fmt, va_list args)
+{
+ char *buffer;
size_t len;
- len = vsnprintf(buffer, sizeof(buffer), str, args);
+ len = valist_to_buf(&buffer, fmt, args);
+ len = log_info_buf(buffer, len);
+ free(buffer);
- return log_info_buf(buffer, min(len, sizeof(buffer) - 1));
+ return len;
}
size_t log_info(const char *format, ...)
{
- char buffer[1024];
va_list args;
- size_t len;
+ size_t ret;
va_start(args, format);
- len = vsnprintf(buffer, sizeof(buffer), format, args);
+ ret = log_valist(format, args);
va_end(args);
- return log_info_buf(buffer, min(len, sizeof(buffer) - 1));
+ return ret;
}
size_t __log_buf(struct buf_output *buf, const char *format, ...)
{
- char buffer[1024];
+ char *buffer;
va_list args;
size_t len;
va_start(args, format);
- len = vsnprintf(buffer, sizeof(buffer), format, args);
+ len = valist_to_buf(&buffer, format, args);
va_end(args);
- return buf_output_add(buf, buffer, min(len, sizeof(buffer) - 1));
+ len = buf_output_add(buf, buffer, len);
+ free(buffer);
+
+ return len;
}
int log_info_flush(void)
size_t log_err(const char *format, ...)
{
- char buffer[1024];
+ size_t ret, len;
+ char *buffer;
va_list args;
- size_t len;
va_start(args, format);
- len = vsnprintf(buffer, sizeof(buffer), format, args);
+ len = valist_to_buf(&buffer, format, args);
va_end(args);
- len = min(len, sizeof(buffer) - 1);
if (is_backend) {
- size_t ret = fio_server_text_output(FIO_LOG_ERR, buffer, len);
+ ret = fio_server_text_output(FIO_LOG_ERR, buffer, len);
if (ret != -1)
- return ret;
+ goto done;
}
if (log_syslog) {
syslog(LOG_INFO, "%s", buffer);
- return len;
+ ret = len;
} else {
- if (f_err != stderr) {
- int fio_unused ret;
-
+ if (f_err != stderr)
ret = fwrite(buffer, len, 1, stderr);
- }
- return fwrite(buffer, len, 1, f_err);
+ ret = fwrite(buffer, len, 1, f_err);
}
+
+done:
+ free(buffer);
+ return ret;
}
const char *log_get_level(int level)
extern size_t log_info_buf(const char *buf, size_t len);
extern int log_info_flush(void);
-#define log_buf(buf, format, args...) \
-do { \
- if ((buf) != NULL) \
- __log_buf(buf, format, ##args); \
- else \
- log_info(format, ##args); \
-} while (0)
+#define log_buf(buf, format, args...) \
+({ \
+ size_t __ret; \
+ if ((buf) != NULL) \
+ __ret = __log_buf(buf, format, ##args); \
+ else \
+ __ret = log_info(format, ##args); \
+ __ret; \
+})
enum {
FIO_LOG_DEBUG = 1,
#define FIO_HAVE_HUGETLB
#define FIO_HAVE_BLKTRACE
#define FIO_HAVE_CL_SIZE
+#define FIO_HAVE_CGROUPS
#define FIO_HAVE_FS_STAT
#define FIO_HAVE_TRIM
#define FIO_HAVE_GETTID
#ifndef CONFIG_NO_SHM
/*
- * The Android NDK doesn't currently export <sys/shm.h>, so define the
- * necessary stuff here.
+ * Bionic doesn't support SysV shared memeory, so implement it using ashmem
*/
-
-#include <sys/shm.h>
-#define SHM_HUGETLB 04000
-
#include <stdio.h>
#include <linux/ashmem.h>
+#include <linux/shm.h>
+#define shmid_ds shmid64_ds
+#define SHM_HUGETLB 04000
#define ASHMEM_DEVICE "/dev/ashmem"
-static inline int shmctl (int __shmid, int __cmd, struct shmid_ds *__buf)
+static inline int shmctl(int __shmid, int __cmd, struct shmid_ds *__buf)
{
int ret=0;
if (__cmd == IPC_RMID)
return ret;
}
-static inline int shmget (key_t __key, size_t __size, int __shmflg)
+static inline int shmget(key_t __key, size_t __size, int __shmflg)
{
int fd,ret;
char keybuf[11];
if (ret < 0)
goto error;
- ret = ioctl(fd, ASHMEM_SET_SIZE, __size);
+ /* Stores size in first 8 bytes, allocate extra space */
+ ret = ioctl(fd, ASHMEM_SET_SIZE, __size + sizeof(uint64_t));
if (ret < 0)
goto error;
return ret;
}
-static inline void *shmat (int __shmid, const void *__shmaddr, int __shmflg)
+static inline void *shmat(int __shmid, const void *__shmaddr, int __shmflg)
{
- size_t *ptr, size = ioctl(__shmid, ASHMEM_GET_SIZE, NULL);
- ptr = mmap(NULL, size + sizeof(size_t), PROT_READ | PROT_WRITE, MAP_SHARED, __shmid, 0);
- *ptr = size; //save size at beginning of buffer, for use with munmap
- return &ptr[1];
+ size_t size = ioctl(__shmid, ASHMEM_GET_SIZE, NULL);
+ /* Needs to be 8-byte aligned to prevent SIGBUS on 32-bit ARM */
+ uint64_t *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, __shmid, 0);
+ /* Save size at beginning of buffer, for use with munmap */
+ *ptr = size;
+ return ptr + 1;
}
static inline int shmdt (const void *__shmaddr)
{
- size_t *ptr, size;
- ptr = (size_t *)__shmaddr;
- ptr--;
- size = *ptr; //find mmap size which we stored at the beginning of the buffer
- return munmap((void *)ptr, size + sizeof(size_t));
+ /* Find mmap size which we stored at the beginning of the buffer */
+ uint64_t *ptr = (uint64_t *)__shmaddr - 1;
+ size_t size = *ptr;
+ return munmap(ptr, size);
}
#endif
#include <linux/unistd.h>
#include <linux/raw.h>
#include <linux/major.h>
+#include <linux/fs.h>
+#include <scsi/sg.h>
#include "./os-linux-syscall.h"
#include "binject.h"
return atoi(size);
}
+#ifdef __powerpc64__
+#define FIO_HAVE_CPU_ONLINE_SYSCONF
+static inline unsigned int cpus_online(void)
+{
+ return sysconf(_SC_NPROCESSORS_CONF);
+}
+#endif
+
static inline unsigned long long get_fs_free_size(const char *path)
{
unsigned long long ret;
ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
ssize_t pwrite(int fildes, const void *buf, size_t nbyte,
off_t offset);
-extern void td_fill_rand_seeds(struct thread_data *);
static inline int blockdev_size(struct fio_file *f, unsigned long long *bytes)
{
return 0;
}
-static inline int init_random_state(struct thread_data *td, unsigned long *rand_seeds, int size)
+static inline int init_random_seeds(unsigned long *rand_seeds, int size)
{
HCRYPTPROV hCryptProv;
}
CryptReleaseContext(hCryptProv, 0);
- td_fill_rand_seeds(td);
return 0;
}
#endif
#endif
-#ifdef FIO_HAVE_SGIO
-#include <linux/fs.h>
-#include <scsi/sg.h>
-#endif
-
#ifndef CONFIG_STRSEP
#include "../oslib/strsep.h"
#endif
__cpu_to_le64(val); \
})
-#ifndef FIO_HAVE_BLKTRACE
-static inline int is_blktrace(const char *fname, int *need_swap)
-{
- return 0;
-}
-struct thread_data;
-static inline int load_blktrace(struct thread_data *td, const char *fname,
- int need_swap)
-{
- return 1;
-}
-#endif
-
#define FIO_DEF_CL_SIZE 128
static inline int os_cache_line_size(void)
#endif
#ifdef FIO_USE_GENERIC_INIT_RANDOM_STATE
-extern void td_fill_rand_seeds(struct thread_data *td);
-/*
- * Initialize the various random states we need (random io, block size ranges,
- * read/write mix, etc).
- */
-static inline int init_random_state(struct thread_data *td, unsigned long *rand_seeds, int size)
+static inline int init_random_seeds(unsigned long *rand_seeds, int size)
{
int fd;
}
close(fd);
- td_fill_rand_seeds(td);
return 0;
}
#endif
}
#endif
-#ifdef __powerpc64__
-#define FIO_HAVE_CPU_ONLINE_SYSCONF
-static inline unsigned int cpus_online(void)
-{
- return sysconf(_SC_NPROCESSORS_CONF);
-}
-#endif
-
#ifndef FIO_HAVE_CPU_ONLINE_SYSCONF
static inline unsigned int cpus_online(void)
{
ret = getsockname(sk, sockaddr_p, &len);
if (ret) {
- log_err("fio: getsockaddr: %s\n", strerror(errno));
+ log_err("fio: getsockname: %s\n", strerror(errno));
return -1;
}
}
for (i = 0; i < FIO_OUTPUT_NR; i++) {
- buf_output_flush(&output[i]);
- buf_output_free(&output[i]);
+ struct buf_output *out = &output[i];
+
+ log_info_buf(out->buf, out->buflen);
+ buf_output_free(out);
}
log_info_flush();
uint32_t nr_pending;
uint32_t nr_setting_up;
- uint32_t files_open;
-
uint64_t m_rate[DDIR_RWDIR_CNT], t_rate[DDIR_RWDIR_CNT];
- uint32_t m_iops[DDIR_RWDIR_CNT], t_iops[DDIR_RWDIR_CNT];
uint64_t rate[DDIR_RWDIR_CNT];
+ uint32_t m_iops[DDIR_RWDIR_CNT], t_iops[DDIR_RWDIR_CNT];
uint32_t iops[DDIR_RWDIR_CNT];
uint64_t elapsed_sec;
uint64_t eta_sec;
uint32_t is_pow2;
uint32_t unit_base;
+ uint32_t files_open;
+
/*
* Network 'copy' of run_str[]
*/
fd = open(fname, O_CREAT | O_TRUNC | O_WRONLY, 0644);
if (fd < 0) {
perror("open verify buf file");
+ free(ptr);
return;
}
projects / fio.git / commitdiff