Add thread_options_pack structure
authorJens Axboe <axboe@kernel.dk>
Thu, 8 Mar 2012 13:52:25 +0000 (14:52 +0100)
committerJens Axboe <axboe@kernel.dk>
Thu, 8 Mar 2012 13:52:25 +0000 (14:52 +0100)
First step towards having an on-disk and on-wire independent
options structure, with the goal being that we parse options
locally (hence allowing them to be edited sanely) and send them
to the server in one nice package.

Additionally, this is a step towards being able to have a new
fio/gfio "project" file format, which includes all the info a
given client needs. This includes job options, where to connect,
etc.

Signed-off-by: Jens Axboe <axboe@kernel.dk>
Makefile
cconv.c [new file with mode: 0644]
options.c
thread_options.h

index 94617688d4ecf2845a6d172b36856bec9ce2ecc4..e1920fb64b52cadc74e0177d17f75ded08025a6a 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -17,7 +17,8 @@ SOURCE := gettime.c ioengines.c init.c stat.c log.c time.c filesetup.c \
                rbtree.c smalloc.c filehash.c profile.c debug.c lib/rand.c \
                lib/num2str.c lib/ieee754.c $(wildcard crc/*.c) engines/cpu.c \
                engines/mmap.c engines/sync.c engines/null.c engines/net.c \
-               memalign.c server.c client.c iolog.c backend.c libfio.c flow.c
+               memalign.c server.c client.c iolog.c backend.c libfio.c flow.c \
+               cconv.c
 
 ifeq ($(UNAME), Linux)
   SOURCE += diskutil.c fifo.c blktrace.c helpers.c cgroup.c trim.c \
diff --git a/cconv.c b/cconv.c
new file mode 100644 (file)
index 0000000..f16e0d6
--- /dev/null
+++ b/cconv.c
@@ -0,0 +1,374 @@
+#include "thread_options.h"
+
+static void string_to_cpu(char **dst, const uint8_t *src)
+{
+       const char *__src = (const char *) src;
+
+       if (strlen(__src))
+               *dst = strdup(__src);
+}
+
+static void string_to_net(uint8_t *dst, const char *src)
+{
+       if (src)
+               strcpy((char *) dst, src);
+       else
+               dst[0] = '\0';
+}
+
+void convert_thread_options_to_cpu(struct thread_options *o,
+                                  struct thread_options_pack *top)
+{
+       int i, j;
+
+       string_to_cpu(&o->description, top->description);
+       string_to_cpu(&o->name, top->name);
+       string_to_cpu(&o->directory, top->directory);
+       string_to_cpu(&o->filename, top->filename);
+       string_to_cpu(&o->opendir, top->opendir);
+       string_to_cpu(&o->ioengine, top->ioengine);
+       string_to_cpu(&o->read_iolog_file, top->read_iolog_file);
+       string_to_cpu(&o->write_iolog_file, top->write_iolog_file);
+       string_to_cpu(&o->bw_log_file, top->bw_log_file);
+       string_to_cpu(&o->lat_log_file, top->lat_log_file);
+       string_to_cpu(&o->iops_log_file, top->iops_log_file);
+       string_to_cpu(&o->replay_redirect, top->replay_redirect);
+       string_to_cpu(&o->exec_prerun, top->exec_prerun);
+       string_to_cpu(&o->exec_postrun, top->exec_postrun);
+       string_to_cpu(&o->ioscheduler, top->ioscheduler);
+       string_to_cpu(&o->profile, top->profile);
+       string_to_cpu(&o->cgroup, top->cgroup);
+
+       o->td_ddir = le32_to_cpu(top->td_ddir);
+       o->rw_seq = le32_to_cpu(top->rw_seq);
+       o->kb_base = le32_to_cpu(top->kb_base);
+       o->ddir_seq_nr = le32_to_cpu(top->ddir_seq_nr);
+       o->ddir_seq_add = le64_to_cpu(top->ddir_seq_add);
+       o->iodepth = le32_to_cpu(top->iodepth);
+       o->iodepth_low = le32_to_cpu(top->iodepth_low);
+       o->iodepth_batch = le32_to_cpu(top->iodepth_batch);
+       o->iodepth_batch_complete = le32_to_cpu(top->iodepth_batch_complete);
+       o->size = le64_to_cpu(top->size);
+       o->size_percent = le32_to_cpu(top->size_percent);
+       o->fill_device = le32_to_cpu(top->fill_device);
+       o->file_size_low = le64_to_cpu(top->file_size_low);
+       o->file_size_high = le64_to_cpu(top->file_size_high);
+       o->start_offset = le64_to_cpu(top->start_offset);
+
+       for (i = 0; i < 2; i++) {
+               o->bs[i] = le32_to_cpu(top->bs[i]);
+               o->ba[i] = le32_to_cpu(top->ba[i]);
+               o->min_bs[i] = le32_to_cpu(top->min_bs[i]);
+               o->max_bs[i] = le32_to_cpu(top->max_bs[i]);
+               o->bssplit_nr[i] = le32_to_cpu(top->bssplit_nr[i]);
+
+               if (o->bssplit_nr[i]) {
+                       o->bssplit[i] = malloc(o->bssplit_nr[i] * sizeof(struct bssplit));
+                       for (j = 0; j < o->bssplit_nr[i]; j++) {
+                               o->bssplit[i][j].bs = le32_to_cpu(top->bssplit[i][j].bs);
+                               o->bssplit[i][j].perc = le32_to_cpu(top->bssplit[i][j].perc);
+                       }
+               }
+
+               o->rwmix[i] = le32_to_cpu(top->rwmix[i]);
+               o->rate[i] = le32_to_cpu(top->rate[i]);
+               o->ratemin[i] = le32_to_cpu(top->ratemin[i]);
+               o->rate_iops[i] = le32_to_cpu(top->rate_iops[i]);
+               o->rate_iops_min[i] = le32_to_cpu(top->rate_iops_min[i]);
+       }
+
+       o->ratecycle = le32_to_cpu(top->ratecycle);
+       o->nr_files = le32_to_cpu(top->nr_files);
+       o->open_files = le32_to_cpu(top->open_files);
+       o->file_lock_mode = le32_to_cpu(top->file_lock_mode);
+       o->lockfile_batch = le32_to_cpu(top->lockfile_batch);
+       o->odirect = le32_to_cpu(top->odirect);
+       o->invalidate_cache = le32_to_cpu(top->invalidate_cache);
+       o->create_serialize = le32_to_cpu(top->create_serialize);
+       o->create_fsync = le32_to_cpu(top->create_fsync);
+       o->create_on_open = le32_to_cpu(top->create_on_open);
+       o->end_fsync = le32_to_cpu(top->end_fsync);
+       o->pre_read = le32_to_cpu(top->pre_read);
+       o->sync_io = le32_to_cpu(top->sync_io);
+       o->verify = le32_to_cpu(top->verify);
+       o->do_verify = le32_to_cpu(top->do_verify);
+       o->verifysort = le32_to_cpu(top->verifysort);
+       o->verify_interval = le32_to_cpu(top->verify_interval);
+       o->verify_offset = le32_to_cpu(top->verify_offset);
+
+       memcpy(o->verify_pattern, top->verify_pattern, MAX_PATTERN_SIZE);
+
+       o->verify_pattern_bytes = le32_to_cpu(top->verify_pattern_bytes);
+       o->verify_fatal = le32_to_cpu(top->verify_fatal);
+       o->verify_dump = le32_to_cpu(top->verify_dump);
+       o->verify_async = le32_to_cpu(top->verify_async);
+       o->verify_batch = le32_to_cpu(top->verify_batch);
+       o->use_thread = le32_to_cpu(top->use_thread);
+       o->unlink = le32_to_cpu(top->unlink);
+       o->do_disk_util = le32_to_cpu(top->do_disk_util);
+       o->override_sync = le32_to_cpu(top->override_sync);
+       o->rand_repeatable = le32_to_cpu(top->rand_repeatable);
+       o->use_os_rand = le32_to_cpu(top->use_os_rand);
+       o->write_lat_log = le32_to_cpu(top->write_lat_log);
+       o->write_bw_log = le32_to_cpu(top->write_bw_log);
+       o->write_iops_log = le32_to_cpu(top->write_iops_log);
+       o->log_avg_msec = le32_to_cpu(top->log_avg_msec);
+       o->norandommap = le32_to_cpu(top->norandommap);
+       o->softrandommap = le32_to_cpu(top->softrandommap);
+       o->bs_unaligned = le32_to_cpu(top->bs_unaligned);
+       o->fsync_on_close = le32_to_cpu(top->fsync_on_close);
+       o->hugepage_size = le32_to_cpu(top->hugepage_size);
+       o->rw_min_bs = le32_to_cpu(top->rw_min_bs);
+       o->thinktime = le32_to_cpu(top->thinktime);
+       o->thinktime_spin = le32_to_cpu(top->thinktime_spin);
+       o->thinktime_blocks = le32_to_cpu(top->thinktime_blocks);
+       o->fsync_blocks = le32_to_cpu(top->fsync_blocks);
+       o->fdatasync_blocks = le32_to_cpu(top->fdatasync_blocks);
+       o->barrier_blocks = le32_to_cpu(top->barrier_blocks);
+
+       o->verify_backlog = le64_to_cpu(top->verify_backlog);
+       o->start_delay = le64_to_cpu(top->start_delay);
+       o->timeout = le64_to_cpu(top->timeout);
+       o->ramp_time = le64_to_cpu(top->ramp_time);
+       o->zone_range = le64_to_cpu(top->zone_range);
+       o->zone_size = le64_to_cpu(top->zone_size);
+       o->zone_skip = le64_to_cpu(top->zone_skip);
+
+       o->overwrite = le32_to_cpu(top->overwrite);
+       o->bw_avg_time = le32_to_cpu(top->bw_avg_time);
+       o->iops_avg_time = le32_to_cpu(top->iops_avg_time);
+       o->loops = le32_to_cpu(top->loops);
+       o->mem_type = le32_to_cpu(top->mem_type);
+       o->mem_align = le32_to_cpu(top->mem_align);
+       o->stonewall = le32_to_cpu(top->stonewall);
+       o->new_group = le32_to_cpu(top->new_group);
+       o->numjobs = le32_to_cpu(top->numjobs);
+       o->cpumask_set = le32_to_cpu(top->cpumask_set);
+       o->verify_cpumask_set = le32_to_cpu(top->verify_cpumask_set);
+       o->iolog = le32_to_cpu(top->iolog);
+       o->rwmixcycle = le32_to_cpu(top->rwmixcycle);
+       o->nice = le32_to_cpu(top->nice);
+       o->file_service_type = le32_to_cpu(top->file_service_type);
+       o->group_reporting = le32_to_cpu(top->group_reporting);
+       o->fadvise_hint = le32_to_cpu(top->fadvise_hint);
+       o->fallocate_mode = le32_to_cpu(top->fallocate_mode);
+       o->zero_buffers = le32_to_cpu(top->zero_buffers);
+       o->refill_buffers = le32_to_cpu(top->refill_buffers);
+       o->scramble_buffers = le32_to_cpu(top->scramble_buffers);
+       o->time_based = le32_to_cpu(top->time_based);
+       o->disable_lat = le32_to_cpu(top->disable_lat);
+       o->disable_clat = le32_to_cpu(top->disable_clat);
+       o->disable_slat = le32_to_cpu(top->disable_slat);
+       o->disable_bw = le32_to_cpu(top->disable_bw);
+       o->gtod_reduce = le32_to_cpu(top->gtod_reduce);
+       o->gtod_cpu = le32_to_cpu(top->gtod_cpu);
+       o->gtod_offload = le32_to_cpu(top->gtod_offload);
+       o->clocksource = le32_to_cpu(top->clocksource);
+       o->no_stall = le32_to_cpu(top->no_stall);
+       o->trim_percentage = le32_to_cpu(top->trim_percentage);
+       o->trim_batch = le32_to_cpu(top->trim_batch);
+       o->trim_zero = le32_to_cpu(top->trim_zero);
+       o->clat_percentiles = le32_to_cpu(top->clat_percentiles);
+       o->overwrite_plist = le32_to_cpu(top->overwrite_plist);
+       o->cpuload = le32_to_cpu(top->cpuload);
+       o->cpucycle = le32_to_cpu(top->cpucycle);
+       o->continue_on_error = le32_to_cpu(top->continue_on_error);
+       o->cgroup_weight = le32_to_cpu(top->cgroup_weight);
+       o->cgroup_nodelete = le32_to_cpu(top->cgroup_nodelete);
+       o->uid = le32_to_cpu(top->uid);
+       o->gid = le32_to_cpu(top->gid);
+       o->flow_id = __le32_to_cpu(top->flow_id);
+       o->flow = __le32_to_cpu(top->flow);
+       o->flow_watermark = __le32_to_cpu(top->flow_watermark);
+       o->flow_sleep = le32_to_cpu(top->flow_sleep);
+       o->sync_file_range = le32_to_cpu(top->sync_file_range);
+
+       o->trim_backlog = le64_to_cpu(top->trim_backlog);
+
+       for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++)
+               o->percentile_list[i].u.f = fio_uint64_to_double(le64_to_cpu(top->percentile_list[i].u.i));
+#if 0
+        uint8_t cpumask[FIO_TOP_STR_MAX];
+        uint8_t verify_cpumask[FIO_TOP_STR_MAX];
+#endif
+}
+
+void convert_thread_options_to_net(struct thread_options_pack *top,
+                                  struct thread_options *o)
+{
+       int i, j;
+
+       string_to_net(top->description, o->description);
+       string_to_net(top->name, o->name);
+       string_to_net(top->directory, o->directory);
+       string_to_net(top->filename, o->filename);
+       string_to_net(top->opendir, o->opendir);
+       string_to_net(top->ioengine, o->ioengine);
+       string_to_net(top->read_iolog_file, o->read_iolog_file);
+       string_to_net(top->write_iolog_file, o->write_iolog_file);
+       string_to_net(top->bw_log_file, o->bw_log_file);
+       string_to_net(top->lat_log_file, o->lat_log_file);
+       string_to_net(top->iops_log_file, o->iops_log_file);
+       string_to_net(top->replay_redirect, o->replay_redirect);
+       string_to_net(top->exec_prerun, o->exec_prerun);
+       string_to_net(top->exec_postrun, o->exec_postrun);
+       string_to_net(top->ioscheduler, o->ioscheduler);
+       string_to_net(top->profile, o->profile);
+       string_to_net(top->cgroup, o->cgroup);
+
+       top->td_ddir = cpu_to_le32(o->td_ddir);
+       top->rw_seq = cpu_to_le32(o->rw_seq);
+       top->kb_base = cpu_to_le32(o->kb_base);
+       top->ddir_seq_nr = cpu_to_le32(o->ddir_seq_nr);
+       top->iodepth = cpu_to_le32(o->iodepth);
+       top->iodepth_low = cpu_to_le32(o->iodepth_low);
+       top->iodepth_batch = cpu_to_le32(o->iodepth_batch);
+       top->iodepth_batch_complete = cpu_to_le32(o->iodepth_batch_complete);
+       top->size_percent = cpu_to_le32(o->size_percent);
+       top->fill_device = cpu_to_le32(o->fill_device);
+       top->ratecycle = cpu_to_le32(o->ratecycle);
+       top->nr_files = cpu_to_le32(o->nr_files);
+       top->open_files = cpu_to_le32(o->open_files);
+       top->file_lock_mode = cpu_to_le32(o->file_lock_mode);
+       top->lockfile_batch = cpu_to_le32(o->lockfile_batch);
+       top->odirect = cpu_to_le32(o->odirect);
+       top->invalidate_cache = cpu_to_le32(o->invalidate_cache);
+       top->create_serialize = cpu_to_le32(o->create_serialize);
+       top->create_fsync = cpu_to_le32(o->create_fsync);
+       top->create_on_open = cpu_to_le32(o->create_on_open);
+       top->end_fsync = cpu_to_le32(o->end_fsync);
+       top->pre_read = cpu_to_le32(o->pre_read);
+       top->sync_io = cpu_to_le32(o->sync_io);
+       top->verify = cpu_to_le32(o->verify);
+       top->do_verify = cpu_to_le32(o->do_verify);
+       top->verifysort = cpu_to_le32(o->verifysort);
+       top->verify_interval = cpu_to_le32(o->verify_interval);
+       top->verify_offset = cpu_to_le32(o->verify_offset);
+       top->verify_pattern_bytes = cpu_to_le32(o->verify_pattern_bytes);
+       top->verify_fatal = cpu_to_le32(o->verify_fatal);
+       top->verify_dump = cpu_to_le32(o->verify_dump);
+       top->verify_async = cpu_to_le32(o->verify_async);
+       top->verify_batch = cpu_to_le32(o->verify_batch);
+       top->use_thread = cpu_to_le32(o->use_thread);
+       top->unlink = cpu_to_le32(o->unlink);
+       top->do_disk_util = cpu_to_le32(o->do_disk_util);
+       top->override_sync = cpu_to_le32(o->override_sync);
+       top->rand_repeatable = cpu_to_le32(o->rand_repeatable);
+       top->use_os_rand = cpu_to_le32(o->use_os_rand);
+       top->write_lat_log = cpu_to_le32(o->write_lat_log);
+       top->write_bw_log = cpu_to_le32(o->write_bw_log);
+       top->write_iops_log = cpu_to_le32(o->write_iops_log);
+       top->log_avg_msec = cpu_to_le32(o->log_avg_msec);
+       top->norandommap = cpu_to_le32(o->norandommap);
+       top->softrandommap = cpu_to_le32(o->softrandommap);
+       top->bs_unaligned = cpu_to_le32(o->bs_unaligned);
+       top->fsync_on_close = cpu_to_le32(o->fsync_on_close);
+       top->hugepage_size = cpu_to_le32(o->hugepage_size);
+       top->rw_min_bs = cpu_to_le32(o->rw_min_bs);
+       top->thinktime = cpu_to_le32(o->thinktime);
+       top->thinktime_spin = cpu_to_le32(o->thinktime_spin);
+       top->thinktime_blocks = cpu_to_le32(o->thinktime_blocks);
+       top->fsync_blocks = cpu_to_le32(o->fsync_blocks);
+       top->fdatasync_blocks = cpu_to_le32(o->fdatasync_blocks);
+       top->barrier_blocks = cpu_to_le32(o->barrier_blocks);
+       top->overwrite = cpu_to_le32(o->overwrite);
+       top->bw_avg_time = cpu_to_le32(o->bw_avg_time);
+       top->iops_avg_time = cpu_to_le32(o->iops_avg_time);
+       top->loops = cpu_to_le32(o->loops);
+       top->mem_type = cpu_to_le32(o->mem_type);
+       top->mem_align = cpu_to_le32(o->mem_align);
+       top->stonewall = cpu_to_le32(o->stonewall);
+       top->new_group = cpu_to_le32(o->new_group);
+       top->numjobs = cpu_to_le32(o->numjobs);
+       top->cpumask_set = cpu_to_le32(o->cpumask_set);
+       top->verify_cpumask_set = cpu_to_le32(o->verify_cpumask_set);
+       top->iolog = cpu_to_le32(o->iolog);
+       top->rwmixcycle = cpu_to_le32(o->rwmixcycle);
+       top->nice = cpu_to_le32(o->nice);
+       top->file_service_type = cpu_to_le32(o->file_service_type);
+       top->group_reporting = cpu_to_le32(o->group_reporting);
+       top->fadvise_hint = cpu_to_le32(o->fadvise_hint);
+       top->fallocate_mode = cpu_to_le32(o->fallocate_mode);
+       top->zero_buffers = cpu_to_le32(o->zero_buffers);
+       top->refill_buffers = cpu_to_le32(o->refill_buffers);
+       top->scramble_buffers = cpu_to_le32(o->scramble_buffers);
+       top->time_based = cpu_to_le32(o->time_based);
+       top->disable_lat = cpu_to_le32(o->disable_lat);
+       top->disable_clat = cpu_to_le32(o->disable_clat);
+       top->disable_slat = cpu_to_le32(o->disable_slat);
+       top->disable_bw = cpu_to_le32(o->disable_bw);
+       top->gtod_reduce = cpu_to_le32(o->gtod_reduce);
+       top->gtod_cpu = cpu_to_le32(o->gtod_cpu);
+       top->gtod_offload = cpu_to_le32(o->gtod_offload);
+       top->clocksource = cpu_to_le32(o->clocksource);
+       top->no_stall = cpu_to_le32(o->no_stall);
+       top->trim_percentage = cpu_to_le32(o->trim_percentage);
+       top->trim_batch = cpu_to_le32(o->trim_batch);
+       top->trim_zero = cpu_to_le32(o->trim_zero);
+       top->clat_percentiles = cpu_to_le32(o->clat_percentiles);
+       top->overwrite_plist = cpu_to_le32(o->overwrite_plist);
+       top->cpuload = cpu_to_le32(o->cpuload);
+       top->cpucycle = cpu_to_le32(o->cpucycle);
+       top->continue_on_error = cpu_to_le32(o->continue_on_error);
+       top->cgroup_weight = cpu_to_le32(o->cgroup_weight);
+       top->cgroup_nodelete = cpu_to_le32(o->cgroup_nodelete);
+       top->uid = cpu_to_le32(o->uid);
+       top->gid = cpu_to_le32(o->gid);
+       top->flow_id = __cpu_to_le32(o->flow_id);
+       top->flow = __cpu_to_le32(o->flow);
+       top->flow_watermark = __cpu_to_le32(o->flow_watermark);
+       top->flow_sleep = cpu_to_le32(o->flow_sleep);
+       top->sync_file_range = cpu_to_le32(o->sync_file_range);
+
+       for (i = 0; i < 2; i++) {
+               top->bs[i] = cpu_to_le32(o->bs[i]);
+               top->ba[i] = cpu_to_le32(o->ba[i]);
+               top->min_bs[i] = cpu_to_le32(o->min_bs[i]);
+               top->max_bs[i] = cpu_to_le32(o->max_bs[i]);
+               top->bssplit_nr[i] = cpu_to_le32(o->bssplit_nr[i]);
+
+               if (o->bssplit_nr[i]) {
+                       unsigned int bssplit_nr = o->bssplit_nr[i];
+
+                       if (bssplit_nr > BSSPLIT_MAX) {
+                               log_err("fio: BSSPLIT_MAX is too small\n");
+                               bssplit_nr = BSSPLIT_MAX;
+                       }
+                       for (j = 0; j < bssplit_nr; j++) {
+                               top->bssplit[i][j].bs = cpu_to_le32(o->bssplit[i][j].bs);
+                               top->bssplit[i][j].perc = cpu_to_le32(o->bssplit[i][j].perc);
+                       }
+               }
+
+               top->rwmix[i] = cpu_to_le32(o->rwmix[i]);
+               top->rate[i] = cpu_to_le32(o->rate[i]);
+               top->ratemin[i] = cpu_to_le32(o->ratemin[i]);
+               top->rate_iops[i] = cpu_to_le32(o->rate_iops[i]);
+               top->rate_iops_min[i] = cpu_to_le32(o->rate_iops_min[i]);
+       }
+
+       memcpy(top->verify_pattern, o->verify_pattern, MAX_PATTERN_SIZE);
+
+       top->size = __cpu_to_le64(o->size);
+       top->verify_backlog = __cpu_to_le64(o->verify_backlog);
+       top->start_delay = __cpu_to_le64(o->start_delay);
+       top->timeout = __cpu_to_le64(o->timeout);
+       top->ramp_time = __cpu_to_le64(o->ramp_time);
+       top->zone_range = __cpu_to_le64(o->zone_range);
+       top->zone_size = __cpu_to_le64(o->zone_size);
+       top->zone_skip = __cpu_to_le64(o->zone_skip);
+       top->ddir_seq_add = __cpu_to_le64(o->ddir_seq_add);
+       top->file_size_low = __cpu_to_le64(o->file_size_low);
+       top->file_size_high = __cpu_to_le64(o->file_size_high);
+       top->start_offset = __cpu_to_le64(o->start_offset);
+       top->trim_backlog = __cpu_to_le64(o->trim_backlog);
+
+       for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++)
+               top->percentile_list[i].u.i = __cpu_to_le64(fio_double_to_uint64(o->percentile_list[i].u.f));
+#if 0
+        uint8_t cpumask[FIO_TOP_STR_MAX];
+        uint8_t verify_cpumask[FIO_TOP_STR_MAX];
+#endif
+
+}
+
index d777efc7efe8293320ed3ff2f529f31047af21a2..a0461d3b88db9527c2023179ea641f7e73d0219a 100644 (file)
--- a/options.c
+++ b/options.c
@@ -160,7 +160,6 @@ static int bssplit_ddir(struct thread_data *td, int ddir, char *str)
        qsort(bssplit, td->o.bssplit_nr[ddir], sizeof(struct bssplit), bs_cmp);
        td->o.bssplit[ddir] = bssplit;
        return 0;
-
 }
 
 static int str_bssplit_cb(void *data, const char *input)
index bb9ba87c515f56967816f37e97846f23fa04d4d8..d46da31b706e31dbd7a131ec2da372e4a060ce10 100644 (file)
@@ -28,9 +28,11 @@ enum error_type {
         ERROR_TYPE_ANY = 0xffff,
 };
 
+#define BSSPLIT_MAX    64
+
 struct bssplit {
-       unsigned int bs;
-       unsigned char perc;
+       uint32_t bs;
+       uint32_t perc;
 };
 
 struct thread_options {
@@ -217,4 +219,192 @@ struct thread_options {
        unsigned int sync_file_range;
 };
 
+#define FIO_TOP_STR_MAX                256
+
+struct thread_options_pack {
+       uint8_t description[FIO_TOP_STR_MAX];
+       uint8_t name[FIO_TOP_STR_MAX];
+       uint8_t directory[FIO_TOP_STR_MAX];
+       uint8_t filename[FIO_TOP_STR_MAX];
+       uint8_t opendir[FIO_TOP_STR_MAX];
+       uint8_t ioengine[FIO_TOP_STR_MAX];
+       uint32_t td_ddir;
+       uint32_t rw_seq;
+       uint32_t kb_base;
+       uint32_t ddir_seq_nr;
+       uint64_t ddir_seq_add;
+       uint32_t iodepth;
+       uint32_t iodepth_low;
+       uint32_t iodepth_batch;
+       uint32_t iodepth_batch_complete;
+
+       uint64_t size;
+       uint32_t size_percent;
+       uint32_t fill_device;
+       uint64_t file_size_low;
+       uint64_t file_size_high;
+       uint64_t start_offset;
+
+       uint32_t bs[2];
+       uint32_t ba[2];
+       uint32_t min_bs[2];
+       uint32_t max_bs[2];
+       struct bssplit bssplit[2][BSSPLIT_MAX];
+       uint32_t bssplit_nr[2];
+
+       uint32_t nr_files;
+       uint32_t open_files;
+       uint32_t file_lock_mode;
+       uint32_t lockfile_batch;
+
+       uint32_t odirect;
+       uint32_t invalidate_cache;
+       uint32_t create_serialize;
+       uint32_t create_fsync;
+       uint32_t create_on_open;
+       uint32_t end_fsync;
+       uint32_t pre_read;
+       uint32_t sync_io;
+       uint32_t verify;
+       uint32_t do_verify;
+       uint32_t verifysort;
+       uint32_t verify_interval;
+       uint32_t verify_offset;
+       uint8_t verify_pattern[MAX_PATTERN_SIZE];
+       uint32_t verify_pattern_bytes;
+       uint32_t verify_fatal;
+       uint32_t verify_dump;
+       uint32_t verify_async;
+       uint64_t verify_backlog;
+       uint32_t verify_batch;
+       uint32_t use_thread;
+       uint32_t unlink;
+       uint32_t do_disk_util;
+       uint32_t override_sync;
+       uint32_t rand_repeatable;
+       uint32_t use_os_rand;
+       uint32_t write_lat_log;
+       uint32_t write_bw_log;
+       uint32_t write_iops_log;
+       uint32_t log_avg_msec;
+       uint32_t norandommap;
+       uint32_t softrandommap;
+       uint32_t bs_unaligned;
+       uint32_t fsync_on_close;
+
+       uint32_t hugepage_size;
+       uint32_t rw_min_bs;
+       uint32_t thinktime;
+       uint32_t thinktime_spin;
+       uint32_t thinktime_blocks;
+       uint32_t fsync_blocks;
+       uint32_t fdatasync_blocks;
+       uint32_t barrier_blocks;
+       uint64_t start_delay;
+       uint64_t timeout;
+       uint64_t ramp_time;
+       uint32_t overwrite;
+       uint32_t bw_avg_time;
+       uint32_t iops_avg_time;
+       uint32_t loops;
+       uint64_t zone_range;
+       uint64_t zone_size;
+       uint64_t zone_skip;
+       uint32_t mem_type;
+       uint32_t mem_align;
+
+       uint32_t stonewall;
+       uint32_t new_group;
+       uint32_t numjobs;
+       uint8_t cpumask[FIO_TOP_STR_MAX];
+       uint32_t cpumask_set;
+       uint8_t verify_cpumask[FIO_TOP_STR_MAX];
+       uint32_t verify_cpumask_set;
+       uint32_t iolog;
+       uint32_t rwmixcycle;
+       uint32_t rwmix[2];
+       uint32_t nice;
+       uint32_t file_service_type;
+       uint32_t group_reporting;
+       uint32_t fadvise_hint;
+       uint32_t fallocate_mode;
+       uint32_t zero_buffers;
+       uint32_t refill_buffers;
+       uint32_t scramble_buffers;
+       uint32_t time_based;
+       uint32_t disable_lat;
+       uint32_t disable_clat;
+       uint32_t disable_slat;
+       uint32_t disable_bw;
+       uint32_t gtod_reduce;
+       uint32_t gtod_cpu;
+       uint32_t gtod_offload;
+       uint32_t clocksource;
+       uint32_t no_stall;
+       uint32_t trim_percentage;
+       uint32_t trim_batch;
+       uint32_t trim_zero;
+       uint64_t trim_backlog;
+       uint32_t clat_percentiles;
+       uint32_t overwrite_plist;
+       fio_fp64_t percentile_list[FIO_IO_U_LIST_MAX_LEN];
+
+       uint8_t read_iolog_file[FIO_TOP_STR_MAX];
+       uint8_t write_iolog_file[FIO_TOP_STR_MAX];
+       uint8_t bw_log_file[FIO_TOP_STR_MAX];
+       uint8_t lat_log_file[FIO_TOP_STR_MAX];
+       uint8_t iops_log_file[FIO_TOP_STR_MAX];
+       uint8_t replay_redirect[FIO_TOP_STR_MAX];
+
+       /*
+        * Pre-run and post-run shell
+        */
+       uint8_t exec_prerun[FIO_TOP_STR_MAX];
+       uint8_t exec_postrun[FIO_TOP_STR_MAX];
+
+       uint32_t rate[2];
+       uint32_t ratemin[2];
+       uint32_t ratecycle;
+       uint32_t rate_iops[2];
+       uint32_t rate_iops_min[2];
+
+       uint8_t ioscheduler[FIO_TOP_STR_MAX];
+
+       /*
+        * CPU "io" cycle burner
+        */
+       uint32_t cpuload;
+       uint32_t cpucycle;
+
+       /*
+        * I/O Error handling
+        */
+       uint32_t continue_on_error;
+
+       /*
+        * Benchmark profile type
+        */
+       uint8_t profile[FIO_TOP_STR_MAX];
+
+       /*
+        * blkio cgroup support
+        */
+       uint8_t cgroup[FIO_TOP_STR_MAX];
+       uint32_t cgroup_weight;
+       uint32_t cgroup_nodelete;
+
+       uint32_t uid;
+       uint32_t gid;
+
+       int32_t flow_id;
+       int32_t flow;
+       int32_t flow_watermark;
+       uint32_t flow_sleep;
+
+       uint32_t sync_file_range;
+} __attribute__((packed));
+
+extern void convert_thread_options_to_cpu(struct thread_options *o, struct thread_options_pack *top);
+extern void convert_thread_options_to_net(struct thread_options_pack *top, struct thread_options *);
+
 #endif