}
}
+/*
+ * The ->file_map[] contains a map of blocks we have or have not done io
+ * to yet. Used to make sure we cover the entire range in a fair fashion.
+ */
static int random_map_free(struct thread_data *td, unsigned long long block)
{
unsigned int idx = RAND_MAP_IDX(td, block);
return (td->file_map[idx] & (1UL << bit)) == 0;
}
+/*
+ * Return the next free block in the map.
+ */
static int get_next_free_block(struct thread_data *td, unsigned long long *b)
{
int i;
return 1;
}
+/*
+ * Mark a given offset as used in the map.
+ */
static void mark_random_map(struct thread_data *td, struct io_u *io_u)
{
unsigned long long block = io_u->offset / (unsigned long long) td->min_bs;
io_u->buflen = blocks * td->min_bs;
}
+/*
+ * For random io, generate a random new block and see if it's used. Repeat
+ * until we find a free one. For sequential io, just return the end of
+ * the last io issued.
+ */
static int get_next_offset(struct thread_data *td, unsigned long long *offset)
{
unsigned long long b, rb;
return buflen;
}
+/*
+ * Check if we are above the minimum rate given.
+ */
static int check_min_rate(struct thread_data *td, struct timeval *now)
{
unsigned long spent;
memcpy(hdr->md5_digest, md5_ctx.hash, sizeof(md5_ctx.hash));
}
+/*
+ * Return the data direction for the next io_u. If the job is a
+ * mixed read/write workload, check the rwmix cycle and switch if
+ * necessary.
+ */
static int get_rw_ddir(struct thread_data *td)
{
if (td_rw(td)) {
return io_u;
}
+/*
+ * Return an io_u to be processed. Gets a buflen and offset, sets direction,
+ * etc. The returned io_u is fully ready to be prepped and submitted.
+ */
static struct io_u *get_io_u(struct thread_data *td)
{
struct io_u *io_u;
}
}
+/*
+ * When job exits, we can cancel the in-flight IO if we are using async
+ * io. Attempt to do so.
+ */
static void cleanup_pending_aio(struct thread_data *td)
{
struct timespec ts = { .tv_sec = 0, .tv_nsec = 0};
return ret;
}
+/*
+ * The main verify engine. Runs over the writes we previusly submitted,
+ * reads the blocks back in, and checks the crc/md5 of the data.
+ */
static void do_verify(struct thread_data *td)
{
struct timeval t;
}
/*
- * Main IO worker functions. It retrieves io_u's to process and queues
+ * Main IO worker function. It retrieves io_u's to process and queues
* and reaps them, checking for rate and errors along the way.
*/
static void do_io(struct thread_data *td)
memset(td->file_map, 0, td->num_maps * sizeof(long));
}
+/*
+ * Entry point for the thread based jobs. The process based jobs end up
+ * here as well, after a little setup.
+ */
static void *thread_main(void *data)
{
struct thread_data *td = data;
}
+/*
+ * We cannot pass the td data into a forked process, so attach the td and
+ * pass it to the thread worker.
+ */
static void *fork_main(int shmid, int offset)
{
struct thread_data *td;
return NULL;
}
+/*
+ * Sets the status of the 'td' in the printed status map.
+ */
static void check_str_update(struct thread_data *td)
{
char c = run_str[td->thread_number - 1];
run_str[td->thread_number - 1] = c;
}
+/*
+ * Convert seconds to a printable string.
+ */
static void eta_to_str(char *str, int eta_sec)
{
unsigned int d, h, m, s;
str += sprintf(str, "%02ds", s);
}
+/*
+ * Best effort calculation of the estimated pending runtime of a job.
+ */
static int thread_eta(struct thread_data *td, unsigned long elapsed)
{
unsigned long long bytes_total, bytes_done;
return eta_sec;
}
+/*
+ * Print status of the jobs we know about. This includes rate estimates,
+ * ETA, thread state, etc.
+ */
static void print_thread_status(void)
{
unsigned long elapsed = time_since_now(&genesis);
free(eta_secs);
}
+/*
+ * Run over the job map and reap the threads that have exited, if any.
+ */
static void reap_threads(int *nr_running, int *t_rate, int *m_rate)
{
int i;
return ptr;
}
+/*
+ * Main function for kicking off and reaping jobs, as needed.
+ */
static void run_threads(void)
{
struct thread_data *td;
+/*
+ * This file contains the ini and command liner parser. It will create
+ * and initialize the specified jobs.
+ */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "fio.h"
+/*
+ * The default options
+ */
#define DEF_BS (4096)
#define DEF_TIMEOUT (0)
#define DEF_RATE_CYCLE (1000)
FILE *f_out = NULL;
FILE *f_err = NULL;
+/*
+ * Return a free job structure.
+ */
static struct thread_data *get_new_job(int global, struct thread_data *parent)
{
struct thread_data *td;
thread_number--;
}
+/*
+ * Adds a job to the list of things todo. Sanitizes the various options
+ * to make sure we don't have conflicts, and initializes various
+ * members of td.
+ */
static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
{
char *ddir_str[] = { "read", "write", "randread", "randwrite",
return -1;
}
+/*
+ * Initialize the various random states we need (random io, block size ranges,
+ * read/write mix, etc).
+ */
int init_random_state(struct thread_data *td)
{
unsigned long seeds[4];
#endif
}
-static unsigned long get_mult(char c)
+static unsigned long get_mult_time(char c)
+{
+ switch (c) {
+ case 'm':
+ case 'M':
+ return 60;
+ case 'h':
+ case 'H':
+ return 60 * 60;
+ case 'd':
+ case 'D':
+ return 24 * 60 * 60;
+ default:
+ return 1;
+ }
+}
+
+static unsigned long get_mult_bytes(char c)
{
switch (c) {
case 'k':
/*
* convert string after '=' into decimal value, noting any size suffix
*/
-static int str_cnv(char *p, unsigned long long *val)
+static int str_to_decimal(char *p, unsigned long long *val, int kilo)
{
char *str;
int len;
if (*val == ULONG_MAX && errno == ERANGE)
return 1;
- *val *= get_mult(str[len - 1]);
+ if (kilo)
+ *val *= get_mult_bytes(str[len - 1]);
+ else
+ *val *= get_mult_time(str[len - 1]);
return 0;
}
-static int check_strcnv(char *p, char *name, unsigned long long *val)
+static int check_str_bytes(char *p, char *name, unsigned long long *val)
{
if (strncmp(p, name, strlen(name) - 1))
return 1;
- return str_cnv(p, val);
+ return str_to_decimal(p, val, 1);
+}
+
+static int check_str_time(char *p, char *name, unsigned long long *val)
+{
+ if (strncmp(p, name, strlen(name) - 1))
+ return 1;
+
+ return str_to_decimal(p, val, 0);
}
static void strip_blank_front(char **p)
return 0;
}
-static int __check_range(char *str, unsigned long *val)
+static int __check_range_bytes(char *str, unsigned long *val)
{
char suffix;
if (sscanf(str, "%lu%c", val, &suffix) == 2) {
- *val *= get_mult(suffix);
+ *val *= get_mult_bytes(suffix);
return 0;
}
return 1;
}
-static int check_range(char *p, char *name, unsigned long *s, unsigned long *e)
+static int check_range_bytes(char *p, char *name, unsigned long *s,
+ unsigned long *e)
{
char option[128];
char *str, *p1, *p2;
p2 = p + 1;
*p = '\0';
- if (!__check_range(p1, s) && !__check_range(p2, e))
+ if (!__check_range_bytes(p1, s) && !__check_range_bytes(p2, e))
return 0;
return 1;
fgetpos(f, &off);
continue;
}
- if (!check_int(p, "timeout", &td->timeout)) {
+ if (!check_str_time(p, "timeout", &ull)) {
+ td->timeout = ul1;
fgetpos(f, &off);
continue;
}
fgetpos(f, &off);
continue;
}
- if (!check_range(p, "bsrange", &ul1, &ul2)) {
+ if (!check_range_bytes(p, "bsrange", &ul1, &ul2)) {
if (ul1 > ul2) {
td->max_bs = ul1;
td->min_bs = ul2;
fgetpos(f, &off);
continue;
}
- if (!check_strcnv(p, "bs", &ull)) {
+ if (!check_str_bytes(p, "bs", &ull)) {
td->bs = ull;
fgetpos(f, &off);
continue;
}
- if (!check_strcnv(p, "size", &td->file_size)) {
+ if (!check_str_bytes(p, "size", &td->file_size)) {
fgetpos(f, &off);
continue;
}
- if (!check_strcnv(p, "offset", &td->file_offset)) {
+ if (!check_str_bytes(p, "offset", &td->file_offset)) {
fgetpos(f, &off);
continue;
}
- if (!check_strcnv(p, "zonesize", &td->zone_size)) {
+ if (!check_str_bytes(p, "zonesize", &td->zone_size)) {
fgetpos(f, &off);
continue;
}
- if (!check_strcnv(p, "zoneskip", &td->zone_skip)) {
+ if (!check_str_bytes(p, "zoneskip", &td->zone_skip)) {
fgetpos(f, &off);
continue;
}
- if (!check_strcnv(p, "lockmem", &mlock_size)) {
+ if (!check_str_bytes(p, "lockmem", &mlock_size)) {
fgetpos(f, &off);
continue;
}
}
}
+/*
+ * The thread area is shared between the main process and the job
+ * threads/processes. So setup a shared memory segment that will hold
+ * all the job info.
+ */
static int setup_thread_area(void)
{
/*
* we get a failure that looks like too large a shm segment
*/
do {
- int s = max_jobs * sizeof(struct thread_data);
+ size_t size = max_jobs * sizeof(struct thread_data);
- shm_id = shmget(0, s, IPC_CREAT | 0600);
+ shm_id = shmget(0, size, IPC_CREAT | 0600);
if (shm_id != -1)
break;
if (errno != EINVAL) {