Recent changes (master)

Jens Axboe
2020-01-07T13:00:14Z

The following changes since commit dbab52955aeb0b58cc88c8eff1b1c2239241f0bd:

Merge branch 'memalign1' of https://github.com/kusumi/fio (2020-01-05 10:31:40 -0700)

are available in the Git repository at:

git://git.kernel.dk/fio.git master

for you to fetch changes up to 2198a6b5a9f40726b40aced24cf2dcdb3b639898:

Merge branch 'master' of https://github.com/bvanassche/fio (2020-01-06 18:38:02 -0700)

----------------------------------------------------------------
Bart Van Assche (12):
Makefile: Avoid duplicating code
Makefile: Use 'tr' if 'fmt' is not available
configure: Improve the ibverbs test
configure: Improve the getopt_long_only() test
Windows: Fix multiple configure tests
Fix the build in case FIO_HAVE_DISK_UTIL is not defined
Change off64_t into uint64_t
Windows: Remove more unused OS dependent code
Include "oslib/asprintf.h" where necessary
Windows: Use snprintf() instead of StringCch*()
Windows: Uninline CPU affinity functions
Windows >= 7: Make fio_getaffinity() error reporting more detailed

Jens Axboe (3):
Merge branch 'json1' of https://github.com/kusumi/fio
Merge branch 'master' of https://github.com/vincentkfu/fio
Merge branch 'master' of https://github.com/bvanassche/fio

Tomohiro Kusumi (1):
json: remove two redundant json_print_array() prototypes

Vincent Fu (2):
t/run-fio-tests: automatically skip t/jobs/t0005 on Windows
t/steadystate_tests: relax acceptance criterion

.appveyor.yml | 2 +-
Makefile | 37 ++--
configure | 43 ++++-
diskutil.h | 2 +-
helpers.c | 3 +-
helpers.h | 4 +-
init.c | 1 +
io_u.c | 2 +-
json.c | 3 +-
os/os-dragonfly.h | 1 -
os/os-freebsd.h | 2 -
os/os-mac.h | 2 -
os/os-netbsd.h | 2 -
os/os-openbsd.h | 2 -
os/os-windows-7.h | 360 -------------------------------------
os/os-windows-xp.h | 67 -------
os/os-windows.h | 17 +-
os/windows/cpu-affinity.c | 444 ++++++++++++++++++++++++++++++++++++++++++++++
os/windows/posix.c | 23 ++-
os/windows/posix.h | 1 -
stat.c | 1 +
t/run-fio-tests.py | 8 +-
t/steadystate_tests.py | 10 +-
verify.c | 1 +
zbd.c | 2 +
25 files changed, 542 insertions(+), 498 deletions(-)
create mode 100644 os/windows/cpu-affinity.c

---

Diff of recent changes:

diff --git a/.appveyor.yml b/.appveyor.yml
index 4fb0a90d..bf0978ad 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -25,7 +25,7 @@ after_build:

test_script:
- 'bash.exe -lc "cd \"${APPVEYOR_BUILD_FOLDER}\" && file.exe fio.exe && make.exe test'
- - 'bash.exe -lc "cd \"${APPVEYOR_BUILD_FOLDER}\" && python.exe t/run-fio-tests.py --skip 5 --debug'
+ - 'bash.exe -lc "cd \"${APPVEYOR_BUILD_FOLDER}\" && python.exe t/run-fio-tests.py --debug'

artifacts:
- path: os\windows\*.msi
diff --git a/Makefile b/Makefile
index dd26afca..3c5e0f5b 100644
--- a/Makefile
+++ b/Makefile
@@ -208,7 +208,8 @@ ifeq ($(CONFIG_TARGET_OS), Darwin)
LIBS += -lpthread -ldl
endif
ifneq (,$(findstring CYGWIN,$(CONFIG_TARGET_OS)))
- SOURCE += os/windows/posix.c
+ SOURCE += os/windows/cpu-affinity.c os/windows/posix.c
+ WINDOWS_OBJS = os/windows/cpu-affinity.o os/windows/posix.o lib/hweight.o
LIBS += -lpthread -lpsapi -lws2_32 -lssp
CFLAGS += -DPSAPI_VERSION=1 -Ios/windows/posix/include -Wno-format
endif
@@ -299,9 +300,9 @@ T_OBJS += $(T_TT_OBJS)
T_OBJS += $(T_IOU_RING_OBJS)

ifneq (,$(findstring CYGWIN,$(CONFIG_TARGET_OS)))
- T_DEDUPE_OBJS += os/windows/posix.o lib/hweight.o
- T_SMALLOC_OBJS += os/windows/posix.o lib/hweight.o
- T_LFSR_TEST_OBJS += os/windows/posix.o lib/hweight.o
+ T_DEDUPE_OBJS += $(WINDOWS_OBJS)
+ T_SMALLOC_OBJS += $(WINDOWS_OBJS)
+ T_LFSR_TEST_OBJS += $(WINDOWS_OBJS)
endif

T_TEST_PROGS = $(T_SMALLOC_PROGS)
@@ -387,13 +388,14 @@ override CFLAGS += -DFIO_VERSION='"$(FIO_VERSION)"'
@$(CC) -MM $(CFLAGS) $(CPPFLAGS) $(SRCDIR)/$*.c > $*.d
@mv -f $*.d $*.d.tmp
@sed -e 's|.*:|$*.o:|' < $*.d.tmp > $*.d
-ifeq ($(CONFIG_TARGET_OS), NetBSD)
- @sed -e 's/.*://' -e 's/\\$$//' < $*.d.tmp | tr -cs "[:graph:]" "\n" | \
- sed -e 's/^ *//' -e '/^$$/ d' -e 's/$$/:/' >> $*.d
-else
- @sed -e 's/.*://' -e 's/\\$$//' < $*.d.tmp | fmt -w 1 | \
- sed -e 's/^ *//' -e 's/$$/:/' >> $*.d
-endif
+ @if type -p fmt >/dev/null 2>&1; then \
+ sed -e 's/.*://' -e 's/\\$$//' < $*.d.tmp | fmt -w 1 | \
+ sed -e 's/^ *//' -e 's/$$/:/' >> $*.d; \
+ else \
+ sed -e 's/.*://' -e 's/\\$$//' < $*.d.tmp | \
+ tr -cs "[:graph:]" "\n" | \
+ sed -e 's/^ *//' -e '/^$$/ d' -e 's/$$/:/' >> $*.d; \
+ fi
@rm -f $*.d.tmp

ifdef CONFIG_ARITHMETIC
@@ -426,19 +428,6 @@ parse.o: lex.yy.o y.tab.o
endif

init.o: init.c FIO-VERSION-FILE
- @mkdir -p $(dir $@)
- $(QUIET_CC)$(CC) -o $@ $(CFLAGS) $(CPPFLAGS) -c $<
- @$(CC) -MM $(CFLAGS) $(CPPFLAGS) $(SRCDIR)/$*.c > $*.d
- @mv -f $*.d $*.d.tmp
- @sed -e 's|.*:|$*.o:|' < $*.d.tmp > $*.d
-ifeq ($(CONFIG_TARGET_OS), NetBSD)
- @sed -e 's/.*://' -e 's/\\$$//' < $*.d.tmp | tr -cs "[:graph:]" "\n" | \
- sed -e 's/^ *//' -e '/^$$/ d' -e 's/$$/:/' >> $*.d
-else
- @sed -e 's/.*://' -e 's/\\$$//' < $*.d.tmp | fmt -w 1 | \
- sed -e 's/^ *//' -e 's/$$/:/' >> $*.d
-endif
- @rm -f $*.d.tmp

gcompat.o: gcompat.c gcompat.h
$(QUIET_CC)$(CC) $(CFLAGS) $(GTK_CFLAGS) $(CPPFLAGS) -c $<
diff --git a/configure b/configure
index fa6df532..a1217700 100755
--- a/configure
+++ b/configure
@@ -381,15 +381,11 @@ CYGWIN*)
# We now take the regular configuration path without having exit 0 here.
# Flags below are still necessary mostly for MinGW.
build_static="yes"
- socklen_t="yes"
rusage_thread="yes"
fdatasync="yes"
clock_gettime="yes" # clock_monotonic probe has dependency on this
clock_monotonic="yes"
- gettimeofday="yes"
sched_idle="yes"
- tcp_nodelay="yes"
- ipv6="yes"
;;
esac

@@ -841,7 +837,7 @@ cat > $TMPC << EOF
int main(int argc, char **argv)
{
struct ibv_pd *pd = ibv_alloc_pd(NULL);
- return 0;
+ return pd != NULL;
}
EOF
if test "$disable_rdma" != "yes" && compile_prog "" "-libverbs" "libverbs" ; then
@@ -1374,7 +1370,7 @@ cat > $TMPC << EOF
#include <getopt.h>
int main(int argc, char **argv)
{
- int c = getopt_long_only(argc, argv, NULL, NULL, NULL);
+ int c = getopt_long_only(argc, argv, "", NULL, NULL);
return c;
}
EOF
@@ -1389,8 +1385,12 @@ if test "$inet_aton" != "yes" ; then
inet_aton="no"
fi
cat > $TMPC << EOF
+#ifdef _WIN32
+#include <winsock2.h>
+#else
#include <sys/socket.h>
#include <arpa/inet.h>
+#endif
#include <stdio.h>
int main(int argc, char **argv)
{
@@ -1409,7 +1409,12 @@ if test "$socklen_t" != "yes" ; then
socklen_t="no"
fi
cat > $TMPC << EOF
+#ifdef _WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#else
#include <sys/socket.h>
+#endif
int main(int argc, char **argv)
{
socklen_t len = 0;
@@ -1533,10 +1538,14 @@ if test "$tcp_nodelay" != "yes" ; then
tcp_nodelay="no"
fi
cat > $TMPC << EOF
+#ifdef _WIN32
+#include <winsock2.h>
+#else
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/tcp.h>
+#endif
int main(int argc, char **argv)
{
return getsockopt(0, 0, TCP_NODELAY, NULL, NULL);
@@ -1544,6 +1553,9 @@ int main(int argc, char **argv)
EOF
if compile_prog "" "" "TCP_NODELAY"; then
tcp_nodelay="yes"
+elif compile_prog "" "-lws2_32" "TCP_NODELAY"; then
+ tcp_nodelay="yes"
+ LIBS="$LIBS -lws2_32"
fi
print_config "TCP_NODELAY" "$tcp_nodelay"

@@ -1553,10 +1565,14 @@ if test "$window_size" != "yes" ; then
window_size="no"
fi
cat > $TMPC << EOF
+#ifdef _WIN32
+#include <winsock2.h>
+#else
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/tcp.h>
+#endif
int main(int argc, char **argv)
{
setsockopt(0, SOL_SOCKET, SO_SNDBUF, NULL, 0);
@@ -1565,6 +1581,9 @@ int main(int argc, char **argv)
EOF
if compile_prog "" "" "SO_SNDBUF"; then
window_size="yes"
+elif compile_prog "" "-lws2_32" "SO_SNDBUF"; then
+ window_size="yes"
+ LIBS="$LIBS -lws2_32"
fi
print_config "Net engine window_size" "$window_size"

@@ -1574,12 +1593,16 @@ if test "$mss" != "yes" ; then
mss="no"
fi
cat > $TMPC << EOF
+#ifdef _WIN32
+#include <winsock2.h>
+#else
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netinet/in.h>
+#endif
int main(int argc, char **argv)
{
return setsockopt(0, IPPROTO_TCP, TCP_MAXSEG, NULL, 0);
@@ -1587,6 +1610,9 @@ int main(int argc, char **argv)
EOF
if compile_prog "" "" "TCP_MAXSEG"; then
mss="yes"
+elif compile_prog "" "-lws2_32" "TCP_MAXSEG"; then
+ mss="yes"
+ LIBS="$LIBS -lws2_32"
fi
print_config "TCP_MAXSEG" "$mss"

@@ -1651,10 +1677,15 @@ if test "$ipv6" != "yes" ; then
ipv6="no"
fi
cat > $TMPC << EOF
+#ifdef _WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
+#endif
#include <stdio.h>
int main(int argc, char **argv)
{
diff --git a/diskutil.h b/diskutil.h
index 15ec681a..f6b09d22 100644
--- a/diskutil.h
+++ b/diskutil.h
@@ -120,7 +120,7 @@ static inline void print_disk_util(struct disk_util_stat *du,
struct buf_output *out)
{
}
-#define show_disk_util(terse, parent, out)
+#define show_disk_util(terse, parent, out) do { } while (0)
#define disk_util_prune_entries()
#define init_disk_util(td)
#define setup_disk_util()
diff --git a/helpers.c b/helpers.c
index a0ee3704..ab9d706d 100644
--- a/helpers.c
+++ b/helpers.c
@@ -18,7 +18,8 @@ int posix_fallocate(int fd, off_t offset, off_t len)
#endif

#ifndef CONFIG_SYNC_FILE_RANGE
-int sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags)
+int sync_file_range(int fd, uint64_t offset, uint64_t nbytes,
+ unsigned int flags)
{
errno = ENOSYS;
return -1;
diff --git a/helpers.h b/helpers.h
index a0b32858..4ec0f052 100644
--- a/helpers.h
+++ b/helpers.h
@@ -7,8 +7,10 @@

extern int fallocate(int fd, int mode, off_t offset, off_t len);
extern int posix_fallocate(int fd, off_t offset, off_t len);
-extern int sync_file_range(int fd, off64_t offset, off64_t nbytes,
+#ifndef CONFIG_SYNC_FILE_RANGE
+extern int sync_file_range(int fd, uint64_t offset, uint64_t nbytes,
unsigned int flags);
+#endif
extern int posix_fadvise(int fd, off_t offset, off_t len, int advice);

#endif /* FIO_HELPERS_H_ */
diff --git a/init.c b/init.c
index 60c85761..2f64726c 100644
--- a/init.c
+++ b/init.c
@@ -32,6 +32,7 @@
#include "steadystate.h"
#include "blktrace.h"

+#include "oslib/asprintf.h"
#include "oslib/getopt.h"
#include "oslib/strcasestr.h"

diff --git a/io_u.c b/io_u.c
index 4a0c725a..03f5c21f 100644
--- a/io_u.c
+++ b/io_u.c
@@ -2182,7 +2182,7 @@ void io_u_fill_buffer(struct thread_data *td, struct io_u *io_u,
static int do_sync_file_range(const struct thread_data *td,
struct fio_file *f)
{
- off64_t offset, nbytes;
+ uint64_t offset, nbytes;

offset = f->first_write;
nbytes = f->last_write - f->first_write;
diff --git a/json.c b/json.c
index 75212c85..e2819a65 100644
--- a/json.c
+++ b/json.c
@@ -230,7 +230,6 @@ int json_object_add_value_type(struct json_object *obj, const char *name, int ty
return 0;
}

-static void json_print_array(struct json_array *array, struct buf_output *);
int json_array_add_value_type(struct json_array *array, int type, ...)
{
struct json_value *value;
@@ -296,8 +295,8 @@ static void json_print_level(int level, struct buf_output *out)
}

static void json_print_pair(struct json_pair *pair, struct buf_output *);
-static void json_print_array(struct json_array *array, struct buf_output *);
static void json_print_value(struct json_value *value, struct buf_output *);
+
void json_print_object(struct json_object *obj, struct buf_output *out)
{
int i;
diff --git a/os/os-dragonfly.h b/os/os-dragonfly.h
index 3c460ae2..44bfcd5d 100644
--- a/os/os-dragonfly.h
+++ b/os/os-dragonfly.h
@@ -47,7 +47,6 @@
/* This is supposed to equal (sizeof(cpumask_t)*8) */
#define FIO_MAX_CPUS SMP_MAXCPU

-typedef off_t off64_t;
typedef cpumask_t os_cpu_mask_t;

/*
diff --git a/os/os-freebsd.h b/os/os-freebsd.h
index 789da178..b3addf98 100644
--- a/os/os-freebsd.h
+++ b/os/os-freebsd.h
@@ -30,8 +30,6 @@
#define fio_swap32(x) bswap32(x)
#define fio_swap64(x) bswap64(x)

-typedef off_t off64_t;
-
typedef cpuset_t os_cpu_mask_t;

#define fio_cpu_clear(mask, cpu) (void) CPU_CLR((cpu), (mask))
diff --git a/os/os-mac.h b/os/os-mac.h
index 0d97f6b9..2852ac67 100644
--- a/os/os-mac.h
+++ b/os/os-mac.h
@@ -33,8 +33,6 @@
*/
#define FIO_MAX_JOBS 128

-typedef off_t off64_t;
-
#ifndef CONFIG_CLOCKID_T
typedef unsigned int clockid_t;
#endif
diff --git a/os/os-netbsd.h b/os/os-netbsd.h
index 88fb3ef1..abc1d3cb 100644
--- a/os/os-netbsd.h
+++ b/os/os-netbsd.h
@@ -35,8 +35,6 @@
#define fio_swap32(x) bswap32(x)
#define fio_swap64(x) bswap64(x)

-typedef off_t off64_t;
-
static inline int blockdev_size(struct fio_file *f, unsigned long long *bytes)
{
struct disklabel dl;
diff --git a/os/os-openbsd.h b/os/os-openbsd.h
index 43a649d4..085a6f2b 100644
--- a/os/os-openbsd.h
+++ b/os/os-openbsd.h
@@ -35,8 +35,6 @@
#define fio_swap32(x) bswap32(x)
#define fio_swap64(x) bswap64(x)

-typedef off_t off64_t;
-
static inline int blockdev_size(struct fio_file *f, unsigned long long *bytes)
{
struct disklabel dl;
diff --git a/os/os-windows-7.h b/os/os-windows-7.h
index 0a6eaa3c..b8bd9e7c 100644
--- a/os/os-windows-7.h
+++ b/os/os-windows-7.h
@@ -5,363 +5,3 @@
typedef struct {
uint64_t row[FIO_CPU_MASK_ROWS];
} os_cpu_mask_t;
-
-#define FIO_HAVE_CPU_ONLINE_SYSCONF
-/* Return all processors regardless of processor group */
-static inline unsigned int cpus_online(void)
-{
- return GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);
-}
-
-static inline void print_mask(os_cpu_mask_t *cpumask)
-{
- for (int i = 0; i < FIO_CPU_MASK_ROWS; i++)
- dprint(FD_PROCESS, "cpumask[%d]=%lu\n", i, cpumask->row[i]);
-}
-
-/* Return the index of the least significant set CPU in cpumask or -1 if no
- * CPUs are set */
-static inline int first_set_cpu(os_cpu_mask_t *cpumask)
-{
- int cpus_offset, mask_first_cpu, row;
-
- cpus_offset = 0;
- row = 0;
- mask_first_cpu = -1;
- while (mask_first_cpu < 0 && row < FIO_CPU_MASK_ROWS) {
- int row_first_cpu;
-
- row_first_cpu = __builtin_ffsll(cpumask->row[row]) - 1;
- dprint(FD_PROCESS, "row_first_cpu=%d cpumask->row[%d]=%lu\n",
- row_first_cpu, row, cpumask->row[row]);
- if (row_first_cpu > -1) {
- mask_first_cpu = cpus_offset + row_first_cpu;
- dprint(FD_PROCESS, "first set cpu in mask is at index %d\n",
- mask_first_cpu);
- } else {
- cpus_offset += FIO_CPU_MASK_STRIDE;
- row++;
- }
- }
-
- return mask_first_cpu;
-}
-
-/* Return the index of the most significant set CPU in cpumask or -1 if no
- * CPUs are set */
-static inline int last_set_cpu(os_cpu_mask_t *cpumask)
-{
- int cpus_offset, mask_last_cpu, row;
-
- cpus_offset = (FIO_CPU_MASK_ROWS - 1) * FIO_CPU_MASK_STRIDE;
- row = FIO_CPU_MASK_ROWS - 1;
- mask_last_cpu = -1;
- while (mask_last_cpu < 0 && row >= 0) {
- int row_last_cpu;
-
- if (cpumask->row[row] == 0)
- row_last_cpu = -1;
- else {
- uint64_t tmp = cpumask->row[row];
-
- row_last_cpu = 0;
- while (tmp >>= 1)
- row_last_cpu++;
- }
-
- dprint(FD_PROCESS, "row_last_cpu=%d cpumask->row[%d]=%lu\n",
- row_last_cpu, row, cpumask->row[row]);
- if (row_last_cpu > -1) {
- mask_last_cpu = cpus_offset + row_last_cpu;
- dprint(FD_PROCESS, "last set cpu in mask is at index %d\n",
- mask_last_cpu);
- } else {
- cpus_offset -= FIO_CPU_MASK_STRIDE;
- row--;
- }
- }
-
- return mask_last_cpu;
-}
-
-static inline int mask_to_group_mask(os_cpu_mask_t *cpumask, int *processor_group, uint64_t *affinity_mask)
-{
- WORD online_groups, group, group_size;
- bool found;
- int cpus_offset, search_cpu, last_cpu, bit_offset, row, end;
- uint64_t group_cpumask;
-
- search_cpu = first_set_cpu(cpumask);
- if (search_cpu < 0) {
- log_info("CPU mask doesn't set any CPUs\n");
- return 1;
- }
-
- /* Find processor group first set CPU applies to */
- online_groups = GetActiveProcessorGroupCount();
- group = 0;
- found = false;
- cpus_offset = 0;
- group_size = 0;
- while (!found && group < online_groups) {
- group_size = GetActiveProcessorCount(group);
- dprint(FD_PROCESS, "group=%d group_start=%d group_size=%u search_cpu=%d\n",
- group, cpus_offset, group_size, search_cpu);
- if (cpus_offset + group_size > search_cpu)
- found = true;
- else {
- cpus_offset += group_size;
- group++;
- }
- }
-
- if (!found) {
- log_err("CPU mask contains processor beyond last active processor index (%d)\n",
- cpus_offset - 1);
- print_mask(cpumask);
- return 1;
- }
-
- /* Check all the CPUs in the mask apply to ONLY that processor group */
- last_cpu = last_set_cpu(cpumask);
- if (last_cpu > (cpus_offset + group_size - 1)) {
- log_info("CPU mask cannot bind CPUs (e.g. %d, %d) that are "
- "in different processor groups\n", search_cpu,
- last_cpu);
- print_mask(cpumask);
- return 1;
- }
-
- /* Extract the current processor group mask from the cpumask */
- row = cpus_offset / FIO_CPU_MASK_STRIDE;
- bit_offset = cpus_offset % FIO_CPU_MASK_STRIDE;
- group_cpumask = cpumask->row[row] >> bit_offset;
- end = bit_offset + group_size;
- if (end > FIO_CPU_MASK_STRIDE && (row + 1 < FIO_CPU_MASK_ROWS)) {
- /* Some of the next row needs to be part of the mask */
- int needed, needed_shift, needed_mask_shift;
- uint64_t needed_mask;
-
- needed = end - FIO_CPU_MASK_STRIDE;
- needed_shift = FIO_CPU_MASK_STRIDE - bit_offset;
- needed_mask_shift = FIO_CPU_MASK_STRIDE - needed;
- needed_mask = (uint64_t)-1 >> needed_mask_shift;
- dprint(FD_PROCESS, "bit_offset=%d end=%d needed=%d needed_shift=%d needed_mask=%ld needed_mask_shift=%d\n", bit_offset, end, needed, needed_shift, needed_mask, needed_mask_shift);
- group_cpumask |= (cpumask->row[row + 1] & needed_mask) << needed_shift;
- }
- group_cpumask &= (uint64_t)-1 >> (FIO_CPU_MASK_STRIDE - group_size);
-
- /* Return group and mask */
- dprint(FD_PROCESS, "Returning group=%d group_mask=%lu\n", group, group_cpumask);
- *processor_group = group;
- *affinity_mask = group_cpumask;
-
- return 0;
-}
-
-static inline int fio_setaffinity(int pid, os_cpu_mask_t cpumask)
-{
- HANDLE handle = NULL;
- int group, ret;
- uint64_t group_mask = 0;
- GROUP_AFFINITY new_group_affinity;
-
- ret = -1;
-
- if (mask_to_group_mask(&cpumask, &group, &group_mask) != 0)
- goto err;
-
- handle = OpenThread(THREAD_QUERY_INFORMATION | THREAD_SET_INFORMATION,
- TRUE, pid);
- if (handle == NULL) {
- log_err("fio_setaffinity: failed to get handle for pid %d\n", pid);
- goto err;
- }
-
- /* Set group and mask.
- * Note: if the GROUP_AFFINITY struct's Reserved members are not
- * initialised to 0 then SetThreadGroupAffinity will fail with
- * GetLastError() set to ERROR_INVALID_PARAMETER */
- new_group_affinity.Mask = (KAFFINITY) group_mask;
- new_group_affinity.Group = group;
- new_group_affinity.Reserved[0] = 0;
- new_group_affinity.Reserved[1] = 0;
- new_group_affinity.Reserved[2] = 0;
- if (SetThreadGroupAffinity(handle, &new_group_affinity, NULL) != 0)
- ret = 0;
- else {
- log_err("fio_setaffinity: failed to set thread affinity "
- "(pid %d, group %d, mask %" PRIx64 ", "
- "GetLastError=%d)\n", pid, group, group_mask,
- GetLastError());
- goto err;
- }
-
-err:
- if (handle)
- CloseHandle(handle);
- return ret;
-}
-
-static inline void cpu_to_row_offset(int cpu, int *row, int *offset)
-{
- *row = cpu / FIO_CPU_MASK_STRIDE;
- *offset = cpu << FIO_CPU_MASK_STRIDE * *row;
-}
-
-static inline int fio_cpuset_init(os_cpu_mask_t *mask)
-{
- for (int i = 0; i < FIO_CPU_MASK_ROWS; i++)
- mask->row[i] = 0;
- return 0;
-}
-
-/*
- * fio_getaffinity() should not be called once a fio_setaffinity() call has
- * been made because fio_setaffinity() may put the process into multiple
- * processor groups
- */
-static inline int fio_getaffinity(int pid, os_cpu_mask_t *mask)
-{
- int ret;
- int row, offset, end, group, group_size, group_start_cpu;
- DWORD_PTR process_mask, system_mask;
- HANDLE handle;
- PUSHORT current_groups;
- USHORT group_count;
- WORD online_groups;
-
- ret = -1;
- current_groups = NULL;
- handle = OpenProcess(PROCESS_QUERY_INFORMATION, TRUE, pid);
- if (handle == NULL) {
- log_err("fio_getaffinity: failed to get handle for pid %d\n",
- pid);
- goto err;
- }
-
- group_count = 1;
- /*
- * GetProcessGroupAffinity() seems to expect more than the natural
- * alignment for a USHORT from the area pointed to by current_groups so
- * arrange for maximum alignment by allocating via malloc()
- */
- current_groups = malloc(sizeof(USHORT));
- if (!current_groups) {
- log_err("fio_getaffinity: malloc failed\n");
- goto err;
- }
- if (GetProcessGroupAffinity(handle, &group_count, current_groups) == 0) {
- /* NB: we also fail here if we are a multi-group process */
- log_err("fio_getaffinity: failed to get single group affinity for pid %d\n", pid);
- goto err;
- }
- GetProcessAffinityMask(handle, &process_mask, &system_mask);
-
- /* Convert group and group relative mask to full CPU mask */
- online_groups = GetActiveProcessorGroupCount();
- if (online_groups == 0) {
- log_err("fio_getaffinity: error retrieving total processor groups\n");
- goto err;
- }
-
- group = 0;
- group_start_cpu = 0;
- group_size = 0;
- dprint(FD_PROCESS, "current_groups=%d group_count=%d\n",
- current_groups[0], group_count);
- while (true) {
- group_size = GetActiveProcessorCount(group);
- if (group_size == 0) {
- log_err("fio_getaffinity: error retrieving size of "
- "processor group %d\n", group);
- goto err;
- } else if (group >= current_groups[0] || group >= online_groups)
- break;
- else {
- group_start_cpu += group_size;
- group++;
- }
- }
-
- if (group != current_groups[0]) {
- log_err("fio_getaffinity: could not find processor group %d\n",
- current_groups[0]);
- goto err;
- }
-
- dprint(FD_PROCESS, "group_start_cpu=%d, group size=%u\n",
- group_start_cpu, group_size);
- if ((group_start_cpu + group_size) >= FIO_MAX_CPUS) {
- log_err("fio_getaffinity failed: current CPU affinity (group "
- "%d, group_start_cpu %d, group_size %d) extends "
- "beyond mask's highest CPU (%d)\n", group,
- group_start_cpu, group_size, FIO_MAX_CPUS);
- goto err;
- }
-
- fio_cpuset_init(mask);
- cpu_to_row_offset(group_start_cpu, &row, &offset);
- mask->row[row] = process_mask;
- mask->row[row] <<= offset;
- end = offset + group_size;
- if (end > FIO_CPU_MASK_STRIDE) {
- int needed;
- uint64_t needed_mask;
-
- needed = FIO_CPU_MASK_STRIDE - end;
- needed_mask = (uint64_t)-1 >> (FIO_CPU_MASK_STRIDE - needed);
- row++;
- mask->row[row] = process_mask;
- mask->row[row] >>= needed;
- mask->row[row] &= needed_mask;
- }
- ret = 0;
-
-err:
- if (handle)
- CloseHandle(handle);
- if (current_groups)
- free(current_groups);
-
- return ret;
-}
-
-static inline void fio_cpu_clear(os_cpu_mask_t *mask, int cpu)
-{
- int row, offset;
- cpu_to_row_offset(cpu, &row, &offset);
-
- mask->row[row] &= ~(1ULL << offset);
-}
-
-static inline void fio_cpu_set(os_cpu_mask_t *mask, int cpu)
-{
- int row, offset;
- cpu_to_row_offset(cpu, &row, &offset);
-
- mask->row[row] |= 1ULL << offset;
-}
-
-static inline int fio_cpu_isset(os_cpu_mask_t *mask, int cpu)
-{
- int row, offset;
- cpu_to_row_offset(cpu, &row, &offset);
-
- return (mask->row[row] & (1ULL << offset)) != 0;
-}
-
-static inline int fio_cpu_count(os_cpu_mask_t *mask)
-{
- int count = 0;
-
- for (int i = 0; i < FIO_CPU_MASK_ROWS; i++)
- count += hweight64(mask->row[i]);
-
- return count;
-}
-
-static inline int fio_cpuset_exit(os_cpu_mask_t *mask)
-{
- return 0;
-}
diff --git a/os/os-windows-xp.h b/os/os-windows-xp.h
index 1ce9ab31..fbc23e2c 100644
--- a/os/os-windows-xp.h
+++ b/os/os-windows-xp.h
@@ -1,70 +1,3 @@
#define FIO_MAX_CPUS MAXIMUM_PROCESSORS

typedef DWORD_PTR os_cpu_mask_t;
-
-static inline int fio_setaffinity(int pid, os_cpu_mask_t cpumask)
-{
- HANDLE h;
- BOOL bSuccess = FALSE;
-
- h = OpenThread(THREAD_QUERY_INFORMATION | THREAD_SET_INFORMATION, TRUE, pid);
- if (h != NULL) {
- bSuccess = SetThreadAffinityMask(h, cpumask);
- if (!bSuccess)
- log_err("fio_setaffinity failed: failed to set thread affinity (pid %d, mask %.16llx)\n", pid, cpumask);
-
- CloseHandle(h);
- } else {
- log_err("fio_setaffinity failed: failed to get handle for pid %d\n", pid);
- }
-
- return (bSuccess)? 0 : -1;
-}
-
-static inline int fio_getaffinity(int pid, os_cpu_mask_t *mask)
-{
- os_cpu_mask_t systemMask;
-
- HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, TRUE, pid);
-
- if (h != NULL) {
- GetProcessAffinityMask(h, mask, &systemMask);
- CloseHandle(h);
- } else {
- log_err("fio_getaffinity failed: failed to get handle for pid %d\n", pid);
- return -1;
- }
-
- return 0;
-}
-
-static inline void fio_cpu_clear(os_cpu_mask_t *mask, int cpu)
-{
- *mask &= ~(1ULL << cpu);
-}
-
-static inline void fio_cpu_set(os_cpu_mask_t *mask, int cpu)
-{
- *mask |= 1ULL << cpu;
-}
-
-static inline int fio_cpu_isset(os_cpu_mask_t *mask, int cpu)
-{
- return (*mask & (1ULL << cpu)) != 0;
-}
-
-static inline int fio_cpu_count(os_cpu_mask_t *mask)
-{
- return hweight64(*mask);
-}
-
-static inline int fio_cpuset_init(os_cpu_mask_t *mask)
-{
- *mask = 0;
- return 0;
-}
-
-static inline int fio_cpuset_exit(os_cpu_mask_t *mask)
-{
- return 0;
-}
diff --git a/os/os-windows.h b/os/os-windows.h
index 6061d8c7..6d48ffe8 100644
--- a/os/os-windows.h
+++ b/os/os-windows.h
@@ -22,11 +22,6 @@

#include "windows/posix.h"

-/* MinGW won't declare rand_r unless _POSIX is defined */
-#if defined(WIN32) && !defined(rand_r)
-int rand_r(unsigned *);
-#endif
-
#ifndef PTHREAD_STACK_MIN
#define PTHREAD_STACK_MIN 65535
#endif
@@ -219,7 +214,19 @@ static inline int fio_mkdir(const char *path, mode_t mode) {
#ifdef CONFIG_WINDOWS_XP
#include "os-windows-xp.h"
#else
+#define FIO_HAVE_CPU_ONLINE_SYSCONF
+unsigned int cpus_online(void);
#include "os-windows-7.h"
#endif

+int first_set_cpu(os_cpu_mask_t *cpumask);
+int fio_setaffinity(int pid, os_cpu_mask_t cpumask);
+int fio_cpuset_init(os_cpu_mask_t *mask);
+int fio_getaffinity(int pid, os_cpu_mask_t *mask);
+void fio_cpu_clear(os_cpu_mask_t *mask, int cpu);
+void fio_cpu_set(os_cpu_mask_t *mask, int cpu);
+int fio_cpu_isset(os_cpu_mask_t *mask, int cpu);
+int fio_cpu_count(os_cpu_mask_t *mask);
+int fio_cpuset_exit(os_cpu_mask_t *mask);
+
#endif /* FIO_OS_WINDOWS_H */
diff --git a/os/windows/cpu-affinity.c b/os/windows/cpu-affinity.c
new file mode 100644
index 00000000..69997b24
--- /dev/null
+++ b/os/windows/cpu-affinity.c
@@ -0,0 +1,444 @@
+#include "os/os.h"
+
+#include <windows.h>
+
+#ifdef CONFIG_WINDOWS_XP
+int fio_setaffinity(int pid, os_cpu_mask_t cpumask)
+{
+ HANDLE h;
+ BOOL bSuccess = FALSE;
+
+ h = OpenThread(THREAD_QUERY_INFORMATION | THREAD_SET_INFORMATION, TRUE,
+ pid);
+ if (h != NULL) {
+ bSuccess = SetThreadAffinityMask(h, cpumask);
+ if (!bSuccess)
+ log_err("fio_setaffinity failed: failed to set thread affinity (pid %d, mask %.16llx)\n",
+ pid, cpumask);
+
+ CloseHandle(h);
+ } else {
+ log_err("fio_setaffinity failed: failed to get handle for pid %d\n",
+ pid);
+ }
+
+ return bSuccess ? 0 : -1;
+}
+
+int fio_getaffinity(int pid, os_cpu_mask_t *mask)
+{
+ os_cpu_mask_t systemMask;
+
+ HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, TRUE, pid);
+
+ if (h != NULL) {
+ GetProcessAffinityMask(h, mask, &systemMask);
+ CloseHandle(h);
+ } else {
+ log_err("fio_getaffinity failed: failed to get handle for pid %d\n",
+ pid);
+ return -1;
+ }
+
+ return 0;
+}
+
+void fio_cpu_clear(os_cpu_mask_t *mask, int cpu)
+{
+ *mask &= ~(1ULL << cpu);
+}
+
+void fio_cpu_set(os_cpu_mask_t *mask, int cpu)
+{
+ *mask |= 1ULL << cpu;
+}
+
+int fio_cpu_isset(os_cpu_mask_t *mask, int cpu)
+{
+ return (*mask & (1ULL << cpu)) != 0;
+}
+
+int fio_cpu_count(os_cpu_mask_t *mask)
+{
+ return hweight64(*mask);
+}
+
+int fio_cpuset_init(os_cpu_mask_t *mask)
+{
+ *mask = 0;
+ return 0;
+}
+
+int fio_cpuset_exit(os_cpu_mask_t *mask)
+{
+ return 0;
+}
+#else /* CONFIG_WINDOWS_XP */
+/* Return all processors regardless of processor group */
+unsigned int cpus_online(void)
+{
+ return GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);
+}
+
+static void print_mask(os_cpu_mask_t *cpumask)
+{
+ for (int i = 0; i < FIO_CPU_MASK_ROWS; i++)
+ dprint(FD_PROCESS, "cpumask[%d]=%lu\n", i, cpumask->row[i]);
+}
+
+/* Return the index of the least significant set CPU in cpumask or -1 if no
+ * CPUs are set */
+int first_set_cpu(os_cpu_mask_t *cpumask)
+{
+ int cpus_offset, mask_first_cpu, row;
+
+ cpus_offset = 0;
+ row = 0;
+ mask_first_cpu = -1;
+ while (mask_first_cpu < 0 && row < FIO_CPU_MASK_ROWS) {
+ int row_first_cpu;
+
+ row_first_cpu = __builtin_ffsll(cpumask->row[row]) - 1;
+ dprint(FD_PROCESS, "row_first_cpu=%d cpumask->row[%d]=%lu\n",
+ row_first_cpu, row, cpumask->row[row]);
+ if (row_first_cpu > -1) {
+ mask_first_cpu = cpus_offset + row_first_cpu;
+ dprint(FD_PROCESS, "first set cpu in mask is at index %d\n",
+ mask_first_cpu);
+ } else {
+ cpus_offset += FIO_CPU_MASK_STRIDE;
+ row++;
+ }
+ }
+
+ return mask_first_cpu;
+}
+
+/* Return the index of the most significant set CPU in cpumask or -1 if no
+ * CPUs are set */
+static int last_set_cpu(os_cpu_mask_t *cpumask)
+{
+ int cpus_offset, mask_last_cpu, row;
+
+ cpus_offset = (FIO_CPU_MASK_ROWS - 1) * FIO_CPU_MASK_STRIDE;
+ row = FIO_CPU_MASK_ROWS - 1;
+ mask_last_cpu = -1;
+ while (mask_last_cpu < 0 && row >= 0) {
+ int row_last_cpu;
+
+ if (cpumask->row[row] == 0)
+ row_last_cpu = -1;
+ else {
+ uint64_t tmp = cpumask->row[row];
+
+ row_last_cpu = 0;
+ while (tmp >>= 1)
+ row_last_cpu++;
+ }
+
+ dprint(FD_PROCESS, "row_last_cpu=%d cpumask->row[%d]=%lu\n",
+ row_last_cpu, row, cpumask->row[row]);
+ if (row_last_cpu > -1) {
+ mask_last_cpu = cpus_offset + row_last_cpu;
+ dprint(FD_PROCESS, "last set cpu in mask is at index %d\n",
+ mask_last_cpu);
+ } else {
+ cpus_offset -= FIO_CPU_MASK_STRIDE;
+ row--;
+ }
+ }
+
+ return mask_last_cpu;
+}
+
+static int mask_to_group_mask(os_cpu_mask_t *cpumask, int *processor_group, uint64_t *affinity_mask)
+{
+ WORD online_groups, group, group_size;
+ bool found;
+ int cpus_offset, search_cpu, last_cpu, bit_offset, row, end;
+ uint64_t group_cpumask;
+
+ search_cpu = first_set_cpu(cpumask);
+ if (search_cpu < 0) {
+ log_info("CPU mask doesn't set any CPUs\n");
+ return 1;
+ }
+
+ /* Find processor group first set CPU applies to */
+ online_groups = GetActiveProcessorGroupCount();
+ group = 0;
+ found = false;
+ cpus_offset = 0;
+ group_size = 0;
+ while (!found && group < online_groups) {
+ group_size = GetActiveProcessorCount(group);
+ dprint(FD_PROCESS, "group=%d group_start=%d group_size=%u search_cpu=%d\n",
+ group, cpus_offset, group_size, search_cpu);
+ if (cpus_offset + group_size > search_cpu)
+ found = true;
+ else {
+ cpus_offset += group_size;
+ group++;
+ }
+ }
+
+ if (!found) {
+ log_err("CPU mask contains processor beyond last active processor index (%d)\n",
+ cpus_offset - 1);
+ print_mask(cpumask);
+ return 1;
+ }
+
+ /* Check all the CPUs in the mask apply to ONLY that processor group */
+ last_cpu = last_set_cpu(cpumask);
+ if (last_cpu > (cpus_offset + group_size - 1)) {
+ log_info("CPU mask cannot bind CPUs (e.g. %d, %d) that are "
+ "in different processor groups\n", search_cpu,
+ last_cpu);
+ print_mask(cpumask);
+ return 1;
+ }
+
+ /* Extract the current processor group mask from the cpumask */
+ row = cpus_offset / FIO_CPU_MASK_STRIDE;
+ bit_offset = cpus_offset % FIO_CPU_MASK_STRIDE;
+ group_cpumask = cpumask->row[row] >> bit_offset;
+ end = bit_offset + group_size;
+ if (end > FIO_CPU_MASK_STRIDE && (row + 1 < FIO_CPU_MASK_ROWS)) {
+ /* Some of the next row needs to be part of the mask */
+ int needed, needed_shift, needed_mask_shift;
+ uint64_t needed_mask;
+
+ needed = end - FIO_CPU_MASK_STRIDE;
+ needed_shift = FIO_CPU_MASK_STRIDE - bit_offset;
+ needed_mask_shift = FIO_CPU_MASK_STRIDE - needed;
+ needed_mask = (uint64_t)-1 >> needed_mask_shift;
+ dprint(FD_PROCESS, "bit_offset=%d end=%d needed=%d needed_shift=%d needed_mask=%ld needed_mask_shift=%d\n", bit_offset, end, needed, needed_shift, needed_mask, needed_mask_shift);
+ group_cpumask |= (cpumask->row[row + 1] & needed_mask) << needed_shift;
+ }
+ group_cpumask &= (uint64_t)-1 >> (FIO_CPU_MASK_STRIDE - group_size);
+
+ /* Return group and mask */
+ dprint(FD_PROCESS, "Returning group=%d group_mask=%lu\n", group, group_cpumask);
+ *processor_group = group;
+ *affinity_mask = group_cpumask;
+
+ return 0;
+}
+
+int fio_setaffinity(int pid, os_cpu_mask_t cpumask)
+{
+ HANDLE handle = NULL;
+ int group, ret;
+ uint64_t group_mask = 0;
+ GROUP_AFFINITY new_group_affinity;
+
+ ret = -1;
+
+ if (mask_to_group_mask(&cpumask, &group, &group_mask) != 0)
+ goto err;
+
+ handle = OpenThread(THREAD_QUERY_INFORMATION | THREAD_SET_INFORMATION,
+ TRUE, pid);
+ if (handle == NULL) {
+ log_err("fio_setaffinity: failed to get handle for pid %d\n", pid);
+ goto err;
+ }
+
+ /* Set group and mask.
+ * Note: if the GROUP_AFFINITY struct's Reserved members are not
+ * initialised to 0 then SetThreadGroupAffinity will fail with
+ * GetLastError() set to ERROR_INVALID_PARAMETER */
+ new_group_affinity.Mask = (KAFFINITY) group_mask;
+ new_group_affinity.Group = group;
+ new_group_affinity.Reserved[0] = 0;
+ new_group_affinity.Reserved[1] = 0;
+ new_group_affinity.Reserved[2] = 0;
+ if (SetThreadGroupAffinity(handle, &new_group_affinity, NULL) != 0)
+ ret = 0;
+ else {
+ log_err("fio_setaffinity: failed to set thread affinity "
+ "(pid %d, group %d, mask %" PRIx64 ", "
+ "GetLastError=%d)\n", pid, group, group_mask,
+ GetLastError());
+ goto err;
+ }
+
+err:
+ if (handle)
+ CloseHandle(handle);
+ return ret;
+}
+
+static void cpu_to_row_offset(int cpu, int *row, int *offset)
+{
+ *row = cpu / FIO_CPU_MASK_STRIDE;
+ *offset = cpu << FIO_CPU_MASK_STRIDE * *row;
+}
+
+int fio_cpuset_init(os_cpu_mask_t *mask)
+{
+ for (int i = 0; i < FIO_CPU_MASK_ROWS; i++)
+ mask->row[i] = 0;
+ return 0;
+}
+
+/*
+ * fio_getaffinity() should not be called once a fio_setaffinity() call has
+ * been made because fio_setaffinity() may put the process into multiple
+ * processor groups
+ */
+int fio_getaffinity(int pid, os_cpu_mask_t *mask)
+{
+ int ret;
+ int row, offset, end, group, group_size, group_start_cpu;
+ DWORD_PTR process_mask, system_mask;
+ HANDLE handle;
+ PUSHORT current_groups;
+ USHORT group_count;
+ WORD online_groups;
+
+ ret = -1;
+ current_groups = NULL;
+ handle = OpenProcess(PROCESS_QUERY_INFORMATION, TRUE, pid);
+ if (handle == NULL) {
+ log_err("fio_getaffinity: failed to get handle for pid %d\n",
+ pid);
+ goto err;
+ }
+
+ group_count = 16;
+ /*
+ * GetProcessGroupAffinity() seems to expect more than the natural
+ * alignment for a USHORT from the area pointed to by current_groups so
+ * arrange for maximum alignment by allocating via malloc()
+ */
+ current_groups = malloc(group_count * sizeof(USHORT));
+ if (!current_groups) {
+ log_err("fio_getaffinity: malloc failed\n");
+ goto err;
+ }
+ if (!GetProcessGroupAffinity(handle, &group_count, current_groups)) {
+ log_err("%s: failed to get single group affinity for pid %d (%d)\n",
+ __func__, pid, GetLastError());
+ goto err;
+ }
+ if (group_count > 1) {
+ log_err("%s: pid %d is associated with %d process groups\n",
+ __func__, pid, group_count);
+ goto err;
+ }
+ if (!GetProcessAffinityMask(handle, &process_mask, &system_mask)) {
+ log_err("%s: GetProcessAffinityMask() failed for pid\n",
+ __func__, pid);
+ goto err;
+ }
+
+ /* Convert group and group relative mask to full CPU mask */
+ online_groups = GetActiveProcessorGroupCount();
+ if (online_groups == 0) {
+ log_err("fio_getaffinity: error retrieving total processor groups\n");
+ goto err;
+ }
+
+ group = 0;
+ group_start_cpu = 0;
+ group_size = 0;
+ dprint(FD_PROCESS, "current_groups=%d group_count=%d\n",
+ current_groups[0], group_count);
+ while (true) {
+ group_size = GetActiveProcessorCount(group);
+ if (group_size == 0) {
+ log_err("fio_getaffinity: error retrieving size of "
+ "processor group %d\n", group);
+ goto err;
+ } else if (group >= current_groups[0] || group >= online_groups)
+ break;
+ else {
+ group_start_cpu += group_size;
+ group++;
+ }
+ }
+
+ if (group != current_groups[0]) {
+ log_err("fio_getaffinity: could not find processor group %d\n",
+ current_groups[0]);
+ goto err;
+ }
+
+ dprint(FD_PROCESS, "group_start_cpu=%d, group size=%u\n",
+ group_start_cpu, group_size);
+ if ((group_start_cpu + group_size) >= FIO_MAX_CPUS) {
+ log_err("fio_getaffinity failed: current CPU affinity (group "
+ "%d, group_start_cpu %d, group_size %d) extends "
+ "beyond mask's highest CPU (%d)\n", group,
+ group_start_cpu, group_size, FIO_MAX_CPUS);
+ goto err;
+ }
+
+ fio_cpuset_init(mask);
+ cpu_to_row_offset(group_start_cpu, &row, &offset);
+ mask->row[row] = process_mask;
+ mask->row[row] <<= offset;
+ end = offset + group_size;
+ if (end > FIO_CPU_MASK_STRIDE) {
+ int needed;
+ uint64_t needed_mask;
+
+ needed = FIO_CPU_MASK_STRIDE - end;
+ needed_mask = (uint64_t)-1 >> (FIO_CPU_MASK_STRIDE - needed);
+ row++;
+ mask->row[row] = process_mask;
+ mask->row[row] >>= needed;
+ mask->row[row] &= needed_mask;
+ }
+ ret = 0;
+
+err:
+ if (handle)
+ CloseHandle(handle);
+ if (current_groups)
+ free(current_groups);
+
+ return ret;
+}
+
+void fio_cpu_clear(os_cpu_mask_t *mask, int cpu)
+{
+ int row, offset;
+ cpu_to_row_offset(cpu, &row, &offset);
+
+ mask->row[row] &= ~(1ULL << offset);
+}
+
+void fio_cpu_set(os_cpu_mask_t *mask, int cpu)
+{
+ int row, offset;
+ cpu_to_row_offset(cpu, &row, &offset);
+
+ mask->row[row] |= 1ULL << offset;
+}
+
+int fio_cpu_isset(os_cpu_mask_t *mask, int cpu)
+{
+ int row, offset;
+ cpu_to_row_offset(cpu, &row, &offset);
+
+ return (mask->row[row] & (1ULL << offset)) != 0;
+}
+
+int fio_cpu_count(os_cpu_mask_t *mask)
+{
+ int count = 0;
+
+ for (int i = 0; i < FIO_CPU_MASK_ROWS; i++)
+ count += hweight64(mask->row[i]);
+
+ return count;
+}
+
+int fio_cpuset_exit(os_cpu_mask_t *mask)
+{
+ return 0;
+}
+#endif /* CONFIG_WINDOWS_XP */
diff --git a/os/windows/posix.c b/os/windows/posix.c
index fd1d5582..e36453e9 100644
--- a/os/windows/posix.c
+++ b/os/windows/posix.c
@@ -28,10 +28,6 @@
extern unsigned long mtime_since_now(struct timespec *);
extern void fio_gettime(struct timespec *, void *);

-/* These aren't defined in the MinGW headers */
-HRESULT WINAPI StringCchCopyA(char *pszDest, size_t cchDest, const char *pszSrc);
-HRESULT WINAPI StringCchPrintfA(char *pszDest, size_t cchDest, const char *pszFormat, ...);
-
int win_to_posix_error(DWORD winerr)
{
switch (winerr) {
@@ -312,11 +308,11 @@ char *ctime_r(const time_t *t, char *buf)
* We don't know how long `buf` is, but assume it's rounded up from
* the minimum of 25 to 32
*/
- StringCchPrintfA(buf, 31, "%s %s %d %02d:%02d:%02d %04d\n",
- dayOfWeek[systime.wDayOfWeek % 7],
- monthOfYear[(systime.wMonth - 1) % 12],
- systime.wDay, systime.wHour, systime.wMinute,
- systime.wSecond, systime.wYear);
+ snprintf(buf, 32, "%s %s %d %02d:%02d:%02d %04d\n",
+ dayOfWeek[systime.wDayOfWeek % 7],
+ monthOfYear[(systime.wMonth - 1) % 12],
+ systime.wDay, systime.wHour, systime.wMinute,
+ systime.wSecond, systime.wYear);
return buf;
}

@@ -958,8 +954,8 @@ DIR *opendir(const char *dirname)
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
if (file != INVALID_HANDLE_VALUE) {
CloseHandle(file);
- dc = (struct dirent_ctx*)malloc(sizeof(struct dirent_ctx));
- StringCchCopyA(dc->dirname, MAX_PATH, dirname);
+ dc = malloc(sizeof(struct dirent_ctx));
+ snprintf(dc->dirname, sizeof(dc->dirname), "%s", dirname);
dc->find_handle = INVALID_HANDLE_VALUE;
} else {
DWORD error = GetLastError();
@@ -999,7 +995,8 @@ struct dirent *readdir(DIR *dirp)
if (dirp->find_handle == INVALID_HANDLE_VALUE) {
char search_pattern[MAX_PATH];

- StringCchPrintfA(search_pattern, MAX_PATH-1, "%s\\*", dirp->dirname);
+ snprintf(search_pattern, sizeof(search_pattern), "%s\\*",
+ dirp->dirname);
dirp->find_handle = FindFirstFileA(search_pattern, &find_data);
if (dirp->find_handle == INVALID_HANDLE_VALUE)
return NULL;
@@ -1008,7 +1005,7 @@ struct dirent *readdir(DIR *dirp)
return NULL;
}

- StringCchCopyA(de.d_name, MAX_PATH, find_data.cFileName);
+ snprintf(de.d_name, sizeof(de.d_name), find_data.cFileName);
de.d_ino = 0;

return &de;
diff --git a/os/windows/posix.h b/os/windows/posix.h
index 85640a21..02a9075b 100644
--- a/os/windows/posix.h
+++ b/os/windows/posix.h
@@ -1,7 +1,6 @@
#ifndef FIO_WINDOWS_POSIX_H
#define FIO_WINDOWS_POSIX_H

-typedef off_t off64_t;
typedef int clockid_t;

extern int clock_gettime(clockid_t clock_id, struct timespec *tp);
diff --git a/stat.c b/stat.c
index e2bc8ddb..2b303494 100644
--- a/stat.c
+++ b/stat.c
@@ -15,6 +15,7 @@
#include "helper_thread.h"
#include "smalloc.h"
#include "zbd.h"
+#include "oslib/asprintf.h"

#define LOG_MSEC_SLACK 1

diff --git a/t/run-fio-tests.py b/t/run-fio-tests.py
index a0a1e8fa..3d236e37 100755
--- a/t/run-fio-tests.py
+++ b/t/run-fio-tests.py
@@ -428,11 +428,13 @@ class Requirements(object):
_root = False
_zoned_nullb = False
_not_macos = False
+ _not_windows = False
_unittests = False
_cpucount4 = False

def __init__(self, fio_root):
Requirements._not_macos = platform.system() != "Darwin"
+ Requirements._not_windows = platform.system() != "Windows"
Requirements._linux = platform.system() == "Linux"

if Requirements._linux:
@@ -470,6 +472,7 @@ class Requirements(object):
Requirements.root,
Requirements.zoned_nullb,
Requirements.not_macos,
+ Requirements.not_windows,
Requirements.unittests,
Requirements.cpucount4]
for req in req_list:
@@ -494,6 +497,9 @@ class Requirements(object):
def not_macos():
return Requirements._not_macos, "platform other than macOS required"

+ def not_windows():
+ return Requirements._not_windows, "platform other than Windows required"
+
def unittests():
return Requirements._unittests, "Unittests support required"

@@ -561,7 +567,7 @@ TEST_LIST = [
'pre_job': None,
'pre_success': None,
'output_format': 'json',
- 'requirements': [],
+ 'requirements': [Requirements.not_windows],
},
{
'test_id': 6,
diff --git a/t/steadystate_tests.py b/t/steadystate_tests.py
index 9122a60f..b55a67ac 100755
--- a/t/steadystate_tests.py
+++ b/t/steadystate_tests.py
@@ -187,7 +187,7 @@ if __name__ == '__main__':
# check runtime, confirm criterion calculation, and confirm that criterion was not met
expected = job['timeout'] * 1000
actual = jsonjob['read']['runtime']
- if abs(expected - actual) > 10:
+ if abs(expected - actual) > 50:
line = 'FAILED ' + line + ' ss not attained, expected runtime {0} != actual runtime {1}'.format(expected, actual)
else:
line = line + ' ss not attained, runtime {0} != ss_dur {1} + ss_ramp {2},'.format(actual, job['ss_dur'], job['ss_ramp'])
@@ -215,12 +215,12 @@ if __name__ == '__main__':
else:
expected = job['timeout'] * 1000
actual = jsonjob['read']['runtime']
- if abs(expected - actual) < 10:
- result = 'PASSED '
- passed = passed + 1
- else:
+ if abs(expected - actual) > 50:
result = 'FAILED '
failed = failed + 1
+ else:
+ result = 'PASSED '
+ passed = passed + 1
line = result + line + ' no ss, expected runtime {0} ~= actual runtime {1}'.format(expected, actual)
print(line)
if 'steadystate' in jsonjob:
diff --git a/verify.c b/verify.c
index 37d2be8d..a2c0d41d 100644
--- a/verify.c
+++ b/verify.c
@@ -14,6 +14,7 @@
#include "lib/rand.h"
#include "lib/hweight.h"
#include "lib/pattern.h"
+#include "oslib/asprintf.h"

#include "crc/md5.h"
#include "crc/crc64.h"
diff --git a/zbd.c b/zbd.c
index 99310c49..ee8bcb30 100644
--- a/zbd.c
+++ b/zbd.c
@@ -13,10 +13,12 @@
#include <sys/stat.h>
#include <unistd.h>
#include <linux/blkzoned.h>
+
#include "file.h"
#include "fio.h"
#include "lib/pow2.h"
#include "log.h"
+#include "oslib/asprintf.h"
#include "smalloc.h"
#include "verify.h"
#include "zbd.h"