stress-copy-file: add --copy-file-io-bytes option

This new option specifies the copy_file_range copy size, the default
is 128K, range 4K to 1MB

Signed-off-by: Colin Ian King <colin.i.king@gmail.com>

Author: ColinIanKing

core-opts.c

@@ -208,6 +208,7 @@ const struct option stress_long_options[] = {
 
 	{ "copy-file",		1,	NULL,	OPT_copy_file },
 	{ "copy-file-bytes",	1,	NULL,	OPT_copy_file_bytes },
+	{ "copy-file-io-bytes",	1,	NULL,	OPT_copy_file_io_bytes },
 	{ "copy-file-ops",	1,	NULL,	OPT_copy_file_ops },
 
 	{ "cpu",		1,	NULL,	OPT_cpu },

core-opts.h

@@ -334,6 +334,7 @@ typedef enum {
 
 	OPT_copy_file,
 	OPT_copy_file_bytes,
+	OPT_copy_file_io_bytes,
 	OPT_copy_file_ops,
 
 	OPT_cpu_load_slice,

stress-copy-file.c

@@ -19,29 +19,35 @@
  */
 #include "stress-ng.h"
 #include "core-builtin.h"
+#include "core-mmap.h"
 
-#define MIN_COPY_FILE_BYTES	(128 * MB)
-#define MAX_COPY_FILE_BYTES	(MAX_FILE_LIMIT)
-#define DEFAULT_COPY_FILE_BYTES	(256 * MB)
-#define DEFAULT_COPY_FILE_SIZE	(128 * KB)
+#define MIN_COPY_FILE_BYTES		(128 * MB)
+#define MAX_COPY_FILE_BYTES		(MAX_FILE_LIMIT)
+#define DEFAULT_COPY_FILE_BYTES		(256 * MB)
+
+#define MIN_COPY_FILE_IO_BYTES		(4 * KB)
+#define MAX_COPY_FILE_IO_BYTES		(1 * MB)
+#define DEFAULT_COPY_FILE_IO_BYTES	(128 * KB)
+
+#define COPY_FILE_MAX_BUF_SIZE		(4096)
 
 static const stress_help_t help[] = {
 	{ NULL,	"copy-file N",		"start N workers that copy file data" },
 	{ NULL,	"copy-file-bytes N",	"specify size of file to be copied" },
+	{ NULL, "copy-file-io-bytes N", "specify copying I/O size" },
 	{ NULL,	"copy-file-ops N",	"stop after N copy bogo operations" },
 	{ NULL,	NULL,			NULL }
 
 };
 
 static const stress_opt_t opts[] = {
-	{ OPT_copy_file_bytes, "copy-file-bytes", TYPE_ID_UINT64_BYTES_FS, MIN_COPY_FILE_BYTES, MAX_COPY_FILE_BYTES, NULL },
+	{ OPT_copy_file_bytes,    "copy-file-bytes",    TYPE_ID_UINT64_BYTES_FS, MIN_COPY_FILE_BYTES, MAX_COPY_FILE_BYTES, NULL },
+	{ OPT_copy_file_io_bytes, "copy-file-io-bytes", TYPE_ID_SIZE_T_BYTES, MIN_COPY_FILE_IO_BYTES, MAX_COPY_FILE_IO_BYTES, NULL },
 	END_OPT,
 };
 
 #if defined(HAVE_COPY_FILE_RANGE)
 
-#define COPY_FILE_MAX_BUF_SIZE	(4096)
-
 /*
  *  stress_copy_file_seek64()
  *	seek with off64_t
@@ -70,19 +76,19 @@ static int stress_copy_file_fill(
 	stress_args_t *args,
 	const int fd,
 	const shim_off64_t off64,
-	const ssize_t size)
+	char * const buf,
+	const size_t buf_len)
 {
-	char buf[COPY_FILE_MAX_BUF_SIZE];
-	ssize_t sz = size;
-
-	(void)shim_memset(buf, stress_mwc8(), sizeof(buf));
+	register ssize_t sz = buf_len;
 
 	if (stress_copy_file_seek64(fd, off64, SEEK_SET) < 0)
 		return -1;
 
+	(void)shim_memset(buf, stress_mwc8(), buf_len);
+
 	while (sz > 0) {
 		ssize_t n;
-		const ssize_t wr_size = sz > (ssize_t)sizeof(buf) ? (ssize_t)sizeof(buf) : sz;
+		const ssize_t wr_size = sz > (ssize_t)buf_len ? (ssize_t)buf_len : sz;
 
 		n = write(fd, buf, wr_size);
 		if (n < 0)
@@ -159,12 +165,28 @@ static int stress_copy_file(stress_args_t *args)
 	const int fd_bad = stress_fs_bad_fd_get();
 	char filename[PATH_MAX - 5];
 	char tmp[PATH_MAX];
+	size_t copy_file_io_bytes = DEFAULT_COPY_FILE_IO_BYTES;
 	uint64_t copy_file_bytes;
 	uint64_t copy_file_bytes_total = DEFAULT_COPY_FILE_BYTES;
 	double duration = 0.0;
 	double bytes = 0.0;
 	double rate;
 	const bool verify = !!(g_opt_flags & OPT_FLAGS_VERIFY);
+	char *buf;
+
+	if (!stress_setting_get("copy-file-io-bytes", &copy_file_io_bytes)) {
+		if (g_opt_flags & OPT_FLAGS_MAXIMIZE)
+			copy_file_io_bytes = MAX_COPY_FILE_IO_BYTES;
+		if (g_opt_flags & OPT_FLAGS_MINIMIZE)
+			copy_file_io_bytes = MIN_COPY_FILE_IO_BYTES;
+	}
+	buf = stress_mmap_populate(NULL, copy_file_io_bytes, PROT_READ | PROT_WRITE,
+			MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+	if (buf == MAP_FAILED) {
+		pr_inf_skip("%s: failed to mmap %zu bytes for I/O buffer, errno=%d (%s), skipping stressor\n",
+			args->name, copy_file_io_bytes, errno, strerror(errno));
+		return EXIT_NO_RESOURCE;
+	}
 
 	if (!stress_setting_get("copy-file-bytes", &copy_file_bytes_total)) {
 		if (g_opt_flags & OPT_FLAGS_MAXIMIZE)
@@ -186,8 +208,8 @@ static int stress_copy_file(stress_args_t *args)
 	}
 
 	copy_file_bytes = copy_file_bytes_total / args->instances;
-	if (copy_file_bytes < DEFAULT_COPY_FILE_SIZE) {
-		copy_file_bytes = DEFAULT_COPY_FILE_SIZE * 2;
+	if (copy_file_bytes < (uint64_t)copy_file_io_bytes) {
+		copy_file_bytes = (uint64_t)copy_file_io_bytes * 2UL;
 		copy_file_bytes_total = copy_file_bytes * args->instances;
 	}
 	if (copy_file_bytes < MIN_COPY_FILE_BYTES) {
@@ -256,19 +278,20 @@ static int stress_copy_file(stress_args_t *args)
 		shim_off64_t off64_out_orig;
 		double t;
 
-		off64_in_orig = (shim_loff_t)stress_mwc64modn(copy_file_bytes - DEFAULT_COPY_FILE_SIZE);
+		/* offsets are between 0.. and end of file - copy size */
+		off64_in_orig = (shim_loff_t)stress_mwc64modn(copy_file_bytes - (uint64_t)copy_file_io_bytes);
 		off64_in = off64_in_orig;
-		off64_out_orig = (shim_loff_t)stress_mwc64modn(copy_file_bytes - DEFAULT_COPY_FILE_SIZE);
+		off64_out_orig = (shim_loff_t)stress_mwc64modn(copy_file_bytes - (uint64_t)copy_file_io_bytes);
 		off64_out = off64_out_orig;
 
 		if (UNLIKELY(!stress_continue(args)))
 			break;
-		stress_copy_file_fill(args, fd_in, off64_in, DEFAULT_COPY_FILE_SIZE);
+		stress_copy_file_fill(args, fd_in, off64_in, buf, copy_file_io_bytes);
 		if (UNLIKELY(!stress_continue(args)))
 			break;
 		t = stress_time_now();
 		copy_ret = shim_copy_file_range(fd_in, &off64_in, fd_out,
-						&off64_out, DEFAULT_COPY_FILE_SIZE, 0);
+						&off64_out, copy_file_io_bytes, 0);
 		if (LIKELY(copy_ret >= 0)) {
 			duration += stress_time_now() - t;
 			bytes += (double)copy_ret;
@@ -315,17 +338,17 @@ static int stress_copy_file(stress_args_t *args)
 		 *  Exercise with bad fds
 		 */
 		VOID_RET(ssize_t, shim_copy_file_range(fd_bad, &off64_in, fd_out,
-						&off64_out, DEFAULT_COPY_FILE_SIZE, 0));
+						&off64_out, copy_file_io_bytes, 0));
 		VOID_RET(ssize_t, shim_copy_file_range(fd_in, &off64_in, fd_bad,
-						&off64_out, DEFAULT_COPY_FILE_SIZE, 0));
+						&off64_out, copy_file_io_bytes, 0));
 		VOID_RET(ssize_t, shim_copy_file_range(fd_out, &off64_in, fd_in,
-						&off64_out, DEFAULT_COPY_FILE_SIZE, 0));
+						&off64_out, copy_file_io_bytes, 0));
 		(void)copy_ret;
 		/*
 		 *  Exercise with bad flags
 		 */
 		VOID_RET(ssize_t, shim_copy_file_range(fd_in, &off64_in, fd_out,
-						&off64_out, DEFAULT_COPY_FILE_SIZE, ~0U));
+						&off64_out, copy_file_io_bytes, ~0U));
 		if (UNLIKELY(!stress_continue(args)))
 			break;
 		(void)shim_fsync(fd_out);
@@ -347,6 +370,8 @@ static int stress_copy_file(stress_args_t *args)
 	stress_proc_state_set(args->name, STRESS_STATE_DEINIT);
 	(void)stress_fs_temp_dir_rm_args(args);
 
+	(void)munmap((void *)buf, copy_file_io_bytes);
+
 	return rc;
 }
 

stress-ng.1

@@ -2169,6 +2169,9 @@ copy file size, the default is 256 MB. One can specify the size as % of free
 space on the file system or in units of Bytes, KBytes, MBytes and GBytes using
 the suffix b, k, m or g.
 .TP
+.B \-\-copy\-file\-io\-bytes N
+copy_file_range(2) copying I/O size, the default is 128 KB, range 4 K to 1 MB.
+.TP
 .B \-\-copy\-file\-ops N
 stop after N copy_file_range() calls.
 .RE