static void
setSparseExtentHeader(SparseExtentHeaderOnDisk *dst,
const SparseExtentHeader *src,
bool temporary)
{
memset(dst, 0, sizeof *dst);
/* Use lowercase 'vmdk' signature for temporary stuff. */
if (temporary) {
dst->magicNumber = __cpu_to_le32(SPARSE_MAGICNUMBER ^ 0x20202020);
} else {
dst->magicNumber = __cpu_to_le32(SPARSE_MAGICNUMBER);
}
dst->version = __cpu_to_le32(src->version);
dst->flags = __cpu_to_le32(src->flags);
dst->singleEndLineChar = SPARSE_SINGLE_END_LINE_CHAR;
dst->nonEndLineChar = SPARSE_NON_END_LINE_CHAR;
dst->doubleEndLineChar1 = SPARSE_DOUBLE_END_LINE_CHAR1;
dst->doubleEndLineChar2 = SPARSE_DOUBLE_END_LINE_CHAR2;
setUnalignedLE16(&dst->compressAlgorithm, src->compressAlgorithm);
dst->uncleanShutdown = src->uncleanShutdown;
setUnalignedLE64(&dst->capacity, src->capacity);
setUnalignedLE64(&dst->grainSize, src->grainSize);
setUnalignedLE64(&dst->descriptorOffset, src->descriptorOffset);
setUnalignedLE64(&dst->descriptorSize, src->descriptorSize);
dst->numGTEsPerGT = __cpu_to_le32(src->numGTEsPerGT);
dst->rgdOffset = __cpu_to_le64(src->rgdOffset);
dst->gdOffset = __cpu_to_le64(src->gdOffset);
dst->overHead = __cpu_to_le64(src->overHead);
}
static int __fill_file_completions(struct thread_data *td,
struct thread_io_list *s,
struct fio_file *f, unsigned int *index)
{
unsigned int comps;
int i, j;
if (!f->last_write_comp)
return 0;
if (td->io_blocks[DDIR_WRITE] < td->o.iodepth)
comps = td->io_blocks[DDIR_WRITE];
else
comps = td->o.iodepth;
j = f->last_write_idx - 1;
for (i = 0; i < comps; i++) {
if (j == -1)
j = td->o.iodepth - 1;
s->comps[*index].fileno = __cpu_to_le64(f->fileno);
s->comps[*index].offset = cpu_to_le64(f->last_write_comp[j]);
(*index)++;
j--;
}
return comps;
}
static bool
writeSpecial(SparseVmdkWriter *writer,
uint32_t marker,
SectorType length)
{
SparseSpecialLBAHeaderOnDisk *specialHdr = writer->zlibBuffer.specialHdr;
memset(writer->zlibBuffer.data, 0, VMDK_SECTOR_SIZE);
specialHdr->lba = __cpu_to_le64(length);
specialHdr->type = __cpu_to_le32(marker);
return safeWrite(writer->fd, specialHdr, VMDK_SECTOR_SIZE);
}
void hfi_flush_egr_bufs(struct _hfi_ctrl *ctrl)
{
uint64_t head = __le64_to_cpu(*ctrl->__hfi_rcvegrhead);
uint64_t tail = __le64_to_cpu(*ctrl->__hfi_rcvegrtail);
if ((head % ctrl->__hfi_tidegrcnt) ==
((tail + 1) % ctrl->__hfi_tidegrcnt)) {
_HFI_DBG
("eager array full after overflow, flushing (head %llx, tail %llx\n",
(long long)head, (long long)tail);
*ctrl->__hfi_rcvegrhead = __cpu_to_le64(tail);
}
}
static void write_firmware(struct firmware *f, unsigned char** r_data, off_t *r_size) {
off_t size;
unsigned int i = 0;
unsigned char* data;
unsigned char* p;
size = HEADER_LENGTH + f->nr_desc * DESC_HEADER_LENGTH;
for(i = 0; i < f->nr_desc; ++i) {
size += f->desc[i].size;
}
data = malloc(size);
p = data;
memcpy(p, f->name, 32);
p += 32;
*(__u16*)p = __cpu_to_le16(f->version);
p += sizeof(f->version);
*(__u16*)p = __cpu_to_le16(f->nr_desc);
p += sizeof(f->nr_desc);
for(i = 0; i < f->nr_desc; ++i) {
*(__u32*) p = __cpu_to_le32(f->desc[i].type);
p += sizeof(f->desc[i].type);
*(__u64*) p = __cpu_to_le64(f->desc[i].id);
p += sizeof(f->desc[i].id);
*(__u32*) p = __cpu_to_le32(f->desc[i].size);
p += sizeof(f->desc[i].size);
memcpy(p, f->desc[i].data, f->desc[i].size);
p += f->desc[i].size;
}
*r_data = data;
*r_size = size;
}
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->filename_format, o->filename_format);
string_to_net(top->opendir, o->opendir);
string_to_net(top->ioengine, o->ioengine);
string_to_net(top->mmapfile, o->mmapfile);
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->unit_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->odirect = cpu_to_le32(o->odirect);
top->oatomic = cpu_to_le32(o->oatomic);
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->create_only = cpu_to_le32(o->create_only);
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->verifysort_nr = cpu_to_le32(o->verifysort_nr);
top->experimental_verify = cpu_to_le32(o->experimental_verify);
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->rand_seed = cpu_to_le32(o->rand_seed);
top->use_os_rand = cpu_to_le32(o->use_os_rand);
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->bs_is_seq_rand = cpu_to_le32(o->bs_is_seq_rand);
top->random_distribution = cpu_to_le32(o->random_distribution);
top->zipf_theta.u.i = __cpu_to_le64(fio_double_to_uint64(o->zipf_theta.u.f));
top->pareto_h.u.i = __cpu_to_le64(fio_double_to_uint64(o->pareto_h.u.f));
top->random_generator = cpu_to_le32(o->random_generator);
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->max_latency = cpu_to_le32(o->max_latency);
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->ioprio = cpu_to_le32(o->ioprio);
top->ioprio_class = cpu_to_le32(o->ioprio_class);
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->unified_rw_rep = cpu_to_le32(o->unified_rw_rep);
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->percentile_precision = cpu_to_le32(o->percentile_precision);
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);
top->latency_target = __cpu_to_le64(o->latency_target);
top->latency_window = __cpu_to_le64(o->latency_window);
top->latency_percentile.u.i = __cpu_to_le64(fio_double_to_uint64(o->latency_percentile.u.f));
top->compress_percentage = cpu_to_le32(o->compress_percentage);
top->compress_chunk = cpu_to_le32(o->compress_chunk);
for (i = 0; i < DDIR_RWDIR_CNT; 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]);
top->perc_rand[i] = cpu_to_le32(o->perc_rand[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->lockmem = __cpu_to_le64(o->lockmem);
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);
top->offset_increment = __cpu_to_le64(o->offset_increment);
top->number_ios = __cpu_to_le64(o->number_ios);
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
}
static void
setUnalignedLE64(__le64 *dst, uint64_t src)
{
uint64_t tmp = __cpu_to_le64(src);
memcpy(dst, &tmp, sizeof *dst);
}
void xle64enc(uint8_t *d, uint64_t n) {
*(uint64_t*)d = __cpu_to_le64(n);
}