static int check_str(char *p, char *name, str_cb_fn *cb, struct thread_data *td)
{
- char *s = strstr(p, name);
+ char *s;
+ if (strncmp(p, name, strlen(name)))
+ return 1;
+
+ s = strstr(p, name);
if (!s)
return 1;
static int check_strstore(char *p, char *name, char *dest)
{
- char *s = strstr(p, name);
+ char *s;
+ if (strncmp(p, name, strlen(name)))
+ return 1;
+
+ s = strstr(p, name);
if (!s)
return 1;
char option[128];
char *str, *p1, *p2;
+ if (strncmp(p, name, strlen(name)))
+ return 1;
+
strcpy(option, p);
p = option;
static int str_iolog_cb(struct thread_data *td, char *file)
{
strncpy(td->iolog_file, file, sizeof(td->iolog_file) - 1);
-
return 0;
}
continue;
}
if (!check_str(p, "iolog", str_iolog_cb, td)) {
- td->iolog = 1;
+ printf("got read iolog\n");
+ td->read_iolog = 1;
+ td->write_iolog = 0;
+ fgetpos(f, &off);
+ continue;
+ }
+ if (!td->read_iolog &&
+ !check_str(p, "write_iolog", str_iolog_cb, td)) {
+ printf("got write iolog\n");
+ td->write_iolog = 1;
fgetpos(f, &off);
continue;
}
td->cur_depth--;
}
-static int fill_io_u(struct thread_data *td, struct io_u *io_u)
+static void write_iolog_put(struct thread_data *td, struct io_u *io_u)
{
- /*
- * If using an iolog, grab next piece if any available.
- */
- if (td->iolog) {
- struct io_piece *ipo;
+ fprintf(td->iolog_f, "%d,%llu,%u\n", io_u->ddir, io_u->offset, io_u->buflen);
+}
- if (list_empty(&td->io_log_list))
- return 1;
+static int read_iolog_get(struct thread_data *td, struct io_u *io_u)
+{
+ struct io_piece *ipo;
+ if (!list_empty(&td->io_log_list)) {
ipo = list_entry(td->io_log_list.next, struct io_piece, list);
list_del(&ipo->list);
io_u->offset = ipo->offset;
return 0;
}
+ return 1;
+}
+
+static int fill_io_u(struct thread_data *td, struct io_u *io_u)
+{
+ /*
+ * If using an iolog, grab next piece if any available.
+ */
+ if (td->read_iolog)
+ return read_iolog_get(td, io_u);
+
/*
* No log, let the seq/rand engine retrieve the next position.
*/
if (io_u->buflen) {
io_u->ddir = get_rw_ddir(td);
+
+ /*
+ * If using a write iolog, store this entry.
+ */
+ if (td->write_iolog)
+ write_iolog_put(td, io_u);
+
return 0;
}
}
return NULL;
}
- if (!td->iolog && !td->sequential)
+ if (!td->read_iolog && !td->sequential)
mark_random_map(td, io_u);
td->last_pos += io_u->buflen;
list_add(&ipo->list, entry);
}
+static void write_iolog_close(struct thread_data *td)
+{
+ fflush(td->iolog_f);
+ fclose(td->iolog_f);
+ free(td->iolog_buf);
+}
+
static int init_iolog(struct thread_data *td)
{
unsigned long long offset;
FILE *f;
int rw, i, reads, writes;
- if (!td->iolog)
+ if (!td->read_iolog && !td->write_iolog)
return 0;
- f = fopen(td->iolog_file, "r");
+ if (td->read_iolog)
+ f = fopen(td->iolog_file, "r");
+ else
+ f = fopen(td->iolog_file, "w");
+
if (!f) {
perror("fopen iolog");
+ printf("file %s, %d/%d\n", td->iolog_file, td->read_iolog, td->write_iolog);
return 1;
}
+ /*
+ * That's it for writing, setup a log buffer and we're done.
+ */
+ if (td->write_iolog) {
+ td->iolog_f = f;
+ td->iolog_buf = malloc(8192);
+ setvbuf(f, td->iolog_buf, _IOFBF, 8192);
+ return 0;
+ }
+
+ /*
+ * Read in the read iolog and store it, reuse the infrastructure
+ * for doing verifications.
+ */
str = malloc(4096);
reads = writes = i = 0;
while ((p = fgets(str, 4096, f)) != NULL) {
td_set_runstate(td, TD_INITIALIZED);
sem_post(&startup_sem);
sem_wait(&td->mutex);
+ ret = 0;
if (!td->create_serialize && setup_file(td))
goto err;
break;
}
- ret = 0;
-
if (td->bw_log)
finish_log(td, td->bw_log, "bw");
if (td->slat_log)
finish_log(td, td->slat_log, "slat");
if (td->clat_log)
finish_log(td, td->clat_log, "clat");
+ if (td->write_iolog)
+ write_iolog_close(td);
if (exitall_on_terminate)
terminate_threads(td->groupid);