#include <fcntl.h>
#include <string.h>
#include <assert.h>
+#include <pthread.h>
#include "fio.h"
+#include "verify.h"
+#include "smalloc.h"
#include "crc/md5.h"
#include "crc/crc64.h"
#include "crc/crc7.h"
#include "crc/sha256.h"
#include "crc/sha512.h"
+#include "crc/sha1.h"
static void fill_random_bytes(struct thread_data *td, void *p, unsigned int len)
{
break;
case VERIFY_CRC32C:
case VERIFY_CRC32:
+ case VERIFY_CRC32C_INTEL:
len = sizeof(struct vhdr_crc32);
break;
case VERIFY_CRC16:
case VERIFY_META:
len = sizeof(struct vhdr_meta);
break;
+ case VERIFY_SHA1:
+ len = sizeof(struct vhdr_sha1);
+ break;
default:
log_err("fio: unknown verify header!\n");
assert(0);
if (vh->offset != io_u->offset + header_num * td->o.verify_interval) {
log_err("meta: verify failed at %llu/%u\n",
io_u->offset + header_num * hdr->len, hdr->len);
- return EIO;
+ return EILSEQ;
}
return 0;
io_u->offset + header_num * hdr->len, hdr->len);
hexdump(vh->sha512, sizeof(vh->sha512));
hexdump(sha512_ctx.buf, sizeof(sha512));
- return EIO;
+ return EILSEQ;
}
return 0;
io_u->offset + header_num * hdr->len, hdr->len);
hexdump(vh->sha256, sizeof(vh->sha256));
hexdump(sha256_ctx.buf, sizeof(sha256));
- return EIO;
+ return EILSEQ;
+ }
+
+ return 0;
+}
+
+static int verify_io_u_sha1(struct verify_header *hdr, struct io_u *io_u,
+ unsigned int header_num)
+{
+ void *p = io_u_verify_off(hdr, io_u, header_num);
+ struct vhdr_sha1 *vh = hdr_priv(hdr);
+ uint32_t sha1[5];
+ struct sha1_ctx sha1_ctx = {
+ .H = sha1,
+ };
+
+ dprint(FD_VERIFY, "sha1 verify io_u %p, len %u\n", io_u, hdr->len);
+
+ sha1_init(&sha1_ctx);
+ sha1_update(&sha1_ctx, p, hdr->len - hdr_size(hdr));
+
+ if (memcmp(vh->sha1, sha1_ctx.H, sizeof(sha1))) {
+ log_err("sha1: verify failed at %llu/%u\n",
+ io_u->offset + header_num * hdr->len, hdr->len);
+ hexdump(vh->sha1, sizeof(vh->sha1));
+ hexdump(sha1_ctx.H, sizeof(sha1));
+ return EILSEQ;
}
return 0;
log_err("crc7: verify failed at %llu/%u\n",
io_u->offset + header_num * hdr->len, hdr->len);
log_err("crc7: wanted %x, got %x\n", vh->crc7, c);
- return EIO;
+ return EILSEQ;
}
return 0;
log_err("crc16: verify failed at %llu/%u\n",
io_u->offset + header_num * hdr->len, hdr->len);
log_err("crc16: wanted %x, got %x\n", vh->crc16, c);
- return EIO;
+ return EILSEQ;
}
return 0;
hdr->len);
log_err("crc64: wanted %llx, got %llx\n",
(unsigned long long) vh->crc64, c);
- return EIO;
+ return EILSEQ;
}
return 0;
log_err("crc32: verify failed at %llu/%u\n",
io_u->offset + header_num * hdr->len, hdr->len);
log_err("crc32: wanted %x, got %x\n", vh->crc32, c);
- return EIO;
+ return EILSEQ;
}
return 0;
dprint(FD_VERIFY, "crc32c verify io_u %p, len %u\n", io_u, hdr->len);
- c = crc32c(p, hdr->len - hdr_size(hdr));
+ if (hdr->verify_type == VERIFY_CRC32C_INTEL)
+ c = crc32c_intel(p, hdr->len - hdr_size(hdr));
+ else
+ c = crc32c(p, hdr->len - hdr_size(hdr));
if (c != vh->crc32) {
log_err("crc32c: verify failed at %llu/%u\n",
io_u->offset + header_num * hdr->len, hdr->len);
log_err("crc32c: wanted %x, got %x\n", vh->crc32, c);
- return EIO;
+ return EILSEQ;
}
return 0;
io_u->offset + header_num * hdr->len, hdr->len);
hexdump(vh->md5_digest, sizeof(vh->md5_digest));
hexdump(md5_ctx.hash, sizeof(hash));
- return EIO;
+ return EILSEQ;
}
return 0;
log_err("fio: got pattern %x, wanted %x. Bad bits %d\n",
buf[i], split_pattern[mod], bits);
log_err("fio: bad pattern block offset %u\n", i);
- return EIO;
+ return EILSEQ;
}
mod++;
if (mod == pattern_size)
return 0;
}
+/*
+ * Push IO verification to a separate thread
+ */
+int verify_io_u_async(struct thread_data *td, struct io_u *io_u)
+{
+ if (io_u->file)
+ put_file_log(td, io_u->file);
+
+ io_u->file = NULL;
+
+ pthread_mutex_lock(&td->io_u_lock);
+ flist_del(&io_u->list);
+ flist_add_tail(&io_u->list, &td->verify_list);
+ pthread_mutex_unlock(&td->io_u_lock);
+
+ pthread_cond_signal(&td->verify_cond);
+ io_u->flags |= IO_U_F_FREE_DEF;
+ return 0;
+}
+
int verify_io_u(struct thread_data *td, struct io_u *io_u)
{
struct verify_header *hdr;
if (hdr->fio_magic != FIO_HDR_MAGIC) {
log_err("Bad verify header %x\n", hdr->fio_magic);
- return EIO;
+ return EILSEQ;
}
if (td->o.verify_pattern_bytes) {
p + hdr_size,
hdr_inc - hdr_size,
hdr_size % 4);
+ /*
+ * Also verify the meta data, if applicable
+ */
+ if (hdr->verify_type == VERIFY_META)
+ ret |= verify_io_u_meta(hdr, td, io_u, hdr_num);
+
if (ret)
log_err("fio: verify failed at %llu/%u\n",
io_u->offset + hdr_num * hdr->len,
ret = verify_io_u_crc64(hdr, io_u, hdr_num);
break;
case VERIFY_CRC32C:
+ case VERIFY_CRC32C_INTEL:
ret = verify_io_u_crc32c(hdr, io_u, hdr_num);
break;
case VERIFY_CRC32:
case VERIFY_META:
ret = verify_io_u_meta(hdr, td, io_u, hdr_num);
break;
+ case VERIFY_SHA1:
+ ret = verify_io_u_sha1(hdr, io_u, hdr_num);
+ break;
default:
log_err("Bad verify type %u\n", hdr->verify_type);
ret = EINVAL;
sha256_update(&sha256_ctx, p, len);
}
+static void fill_sha1(struct verify_header *hdr, void *p, unsigned int len)
+{
+ struct vhdr_sha1 *vh = hdr_priv(hdr);
+ struct sha1_ctx sha1_ctx = {
+ .H = vh->sha1,
+ };
+
+ sha1_init(&sha1_ctx);
+ sha1_update(&sha1_ctx, p, len);
+}
+
static void fill_crc7(struct verify_header *hdr, void *p, unsigned int len)
{
struct vhdr_crc7 *vh = hdr_priv(hdr);
{
struct vhdr_crc32 *vh = hdr_priv(hdr);
- vh->crc32 = crc32c(p, len);
+ if (hdr->verify_type == VERIFY_CRC32C_INTEL)
+ vh->crc32 = crc32c_intel(p, len);
+ else
+ vh->crc32 = crc32c(p, len);
}
static void fill_crc64(struct verify_header *hdr, void *p, unsigned int len)
fill_crc64(hdr, data, data_len);
break;
case VERIFY_CRC32C:
+ case VERIFY_CRC32C_INTEL:
dprint(FD_VERIFY, "fill crc32c io_u %p, len %u\n",
io_u, hdr->len);
fill_crc32c(hdr, data, data_len);
io_u, hdr->len);
fill_meta(hdr, td, io_u, header_num);
break;
+ case VERIFY_SHA1:
+ dprint(FD_VERIFY, "fill sha1 io_u %p, len %u\n",
+ io_u, hdr->len);
+ fill_sha1(hdr, data, data_len);
+ break;
default:
log_err("fio: bad verify type: %d\n", td->o.verify);
assert(0);
io_u->buflen = ipo->len;
io_u->file = ipo->file;
- if ((io_u->file->flags & FIO_FILE_OPEN) == 0) {
+ if (!fio_file_open(io_u->file)) {
int r = td_io_open_file(td, io_u->file);
if (r) {
}
get_file(ipo->file);
- assert(io_u->file->flags & FIO_FILE_OPEN);
+ assert(fio_file_open(io_u->file));
io_u->ddir = DDIR_READ;
io_u->xfer_buf = io_u->buf;
io_u->xfer_buflen = io_u->buflen;
dprint(FD_VERIFY, "get_next_verify: empty\n");
return 1;
}
+
+static void *verify_async_thread(void *data)
+{
+ struct thread_data *td = data;
+ struct io_u *io_u;
+ int ret = 0;
+
+ if (td->o.verify_cpumask_set &&
+ fio_setaffinity(td->pid, td->o.verify_cpumask)) {
+ log_err("fio: failed setting verify thread affinity\n");
+ goto done;
+ }
+
+ do {
+ FLIST_HEAD(list);
+
+ read_barrier();
+ if (td->verify_thread_exit)
+ break;
+
+ pthread_mutex_lock(&td->io_u_lock);
+
+ while (flist_empty(&td->verify_list) &&
+ !td->verify_thread_exit) {
+ ret = pthread_cond_wait(&td->verify_cond,
+ &td->io_u_lock);
+ if (ret) {
+ pthread_mutex_unlock(&td->io_u_lock);
+ break;
+ }
+ }
+
+ flist_splice_init(&td->verify_list, &list);
+ pthread_mutex_unlock(&td->io_u_lock);
+
+ if (flist_empty(&list))
+ continue;
+
+ while (!flist_empty(&list)) {
+ io_u = flist_entry(list.next, struct io_u, list);
+ flist_del_init(&io_u->list);
+
+ ret = verify_io_u(td, io_u);
+ put_io_u(td, io_u);
+ if (!ret)
+ continue;
+ if (td->o.continue_on_error &&
+ td_non_fatal_error(ret)) {
+ update_error_count(td, ret);
+ td_clear_error(td);
+ ret = 0;
+ }
+ }
+ } while (!ret);
+
+ if (ret) {
+ td_verror(td, ret, "async_verify");
+ td->terminate = 1;
+ }
+
+done:
+ pthread_mutex_lock(&td->io_u_lock);
+ td->nr_verify_threads--;
+ pthread_mutex_unlock(&td->io_u_lock);
+
+ pthread_cond_signal(&td->free_cond);
+ return NULL;
+}
+
+int verify_async_init(struct thread_data *td)
+{
+ int i, ret;
+
+ td->verify_thread_exit = 0;
+
+ td->verify_threads = malloc(sizeof(pthread_t) * td->o.verify_async);
+ for (i = 0; i < td->o.verify_async; i++) {
+ ret = pthread_create(&td->verify_threads[i], NULL,
+ verify_async_thread, td);
+ if (ret) {
+ log_err("fio: async verify creation failed: %s\n",
+ strerror(ret));
+ break;
+ }
+ ret = pthread_detach(td->verify_threads[i]);
+ if (ret) {
+ log_err("fio: async verify thread detach failed: %s\n",
+ strerror(ret));
+ break;
+ }
+ td->nr_verify_threads++;
+ }
+
+ if (i != td->o.verify_async) {
+ log_err("fio: only %d verify threads started, exiting\n", i);
+ td->verify_thread_exit = 1;
+ write_barrier();
+ pthread_cond_broadcast(&td->verify_cond);
+ return 1;
+ }
+
+ return 0;
+}
+
+void verify_async_exit(struct thread_data *td)
+{
+ td->verify_thread_exit = 1;
+ write_barrier();
+ pthread_cond_broadcast(&td->verify_cond);
+
+ pthread_mutex_lock(&td->io_u_lock);
+
+ while (td->nr_verify_threads)
+ pthread_cond_wait(&td->free_cond, &td->io_u_lock);
+
+ pthread_mutex_unlock(&td->io_u_lock);
+ free(td->verify_threads);
+ td->verify_threads = NULL;
+}