Reduce thread stack size

[fio.git] / verify.c

diff --git a/verify.c b/verify.c
index e827d76edc82a8dee04ea99394a7e19cd7012d73..7957bd4110d88bea8aecc242c6460f739871ef99 100644 (file)
--- a/verify.c
+++ b/verify.c
@@ -10,6 +10,7 @@
 #include "fio.h"
 #include "verify.h"
 #include "smalloc.h"
+#include "lib/rand.h"
 
 #include "crc/md5.h"
 #include "crc/crc64.h"
@@ -21,44 +22,31 @@
 #include "crc/sha512.h"
 #include "crc/sha1.h"
 
-static void fill_random_bytes(struct thread_data *td, void *p, unsigned int len)
-{
-       unsigned int todo;
-       int r;
-
-       while (len) {
-               r = os_random_long(&td->verify_state);
-
-               /*
-                * lrand48_r seems to be broken and only fill the bottom
-                * 32-bits, even on 64-bit archs with 64-bit longs
-                */
-               todo = sizeof(r);
-               if (todo > len)
-                       todo = len;
-
-               memcpy(p, &r, todo);
-
-               len -= todo;
-               p += todo;
-       }
-}
-
-static void fill_pattern(struct thread_data *td, void *p, unsigned int len)
+void fill_pattern(struct thread_data *td, void *p, unsigned int len, struct io_u *io_u)
 {
        switch (td->o.verify_pattern_bytes) {
        case 0:
                dprint(FD_VERIFY, "fill random bytes len=%u\n", len);
-               fill_random_bytes(td, p, len);
+               fill_random_buf(p, len);
                break;
        case 1:
+               if (io_u->buf_filled_len >= len) {
+                       dprint(FD_VERIFY, "using already filled verify pattern b=0 len=%u\n", len);
+                       return;
+               }
                dprint(FD_VERIFY, "fill verify pattern b=0 len=%u\n", len);
                memset(p, td->o.verify_pattern[0], len);
+               io_u->buf_filled_len = len;
                break;
        default: {
                unsigned int i = 0, size = 0;
                unsigned char *b = p;
 
+               if (io_u->buf_filled_len >= len) {
+                       dprint(FD_VERIFY, "using already filled verify pattern b=%d len=%u\n",
+                                       td->o.verify_pattern_bytes, len);
+                       return;
+               }
                dprint(FD_VERIFY, "fill verify pattern b=%d len=%u\n",
                                        td->o.verify_pattern_bytes, len);
 
@@ -69,6 +57,7 @@ static void fill_pattern(struct thread_data *td, void *p, unsigned int len)
                        memcpy(b+i, td->o.verify_pattern, size);
                        i += size;
                }
+               io_u->buf_filled_len = len;
                break;
                }
        }
@@ -182,8 +171,8 @@ static void log_verify_failure(struct verify_header *hdr, struct vcont *vc)
 
        offset = vc->io_u->offset;
        offset += vc->hdr_num * hdr->len;
-       log_err("%.8s: verify failed at file offset %llu, length %u\n",
-                       vc->name, offset, hdr->len);
+       log_err("%.8s: verify failed at file %s offset %llu, length %u\n",
+                       vc->name, vc->io_u->file->file_name, offset, hdr->len);
 
        if (vc->good_crc && vc->bad_crc) {
                log_err("       Expected CRC: ");
@@ -503,19 +492,19 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u)
                        .hdr_num        = hdr_num,
                };
 
-               if (ret && td->o.verify_fatal) {
-                       td->terminate = 1;
+               if (ret && td->o.verify_fatal)
                        break;
-               }
+
                hdr_size = __hdr_size(td->o.verify);
                if (td->o.verify_offset)
                        memswp(p, p + td->o.verify_offset, hdr_size);
                hdr = p;
 
                if (hdr->fio_magic != FIO_HDR_MAGIC) {
-                       log_err("Bad verify header %x at %llu\n",
-                                       hdr->fio_magic,
-                                       io_u->offset + hdr_num * hdr->len);
+                       log_err("verify: bad magic header %x, wanted %x at file %s offset %llu, length %u\n",
+                               hdr->fio_magic, FIO_HDR_MAGIC,
+                               io_u->file->file_name,
+                               io_u->offset + hdr_num * hdr->len, hdr->len);
                        return EILSEQ;
                }
 
@@ -527,16 +516,19 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u)
                                  p + hdr_size,
                                  hdr_inc - hdr_size,
                                  hdr_size % td->o.verify_pattern_bytes);
+
+                       if (ret) {
+                               log_err("pattern: verify failed at file %s offset %llu, length %u\n",
+                                       io_u->file->file_name,
+                                       io_u->offset + hdr_num * hdr->len,
+                                       hdr->len);
+                       }
+
                        /*
                         * Also verify the meta data, if applicable
                         */
                        if (hdr->verify_type == VERIFY_META)
                                ret |= verify_io_u_meta(hdr, td, &vc);
-
-                       if (ret)
-                               log_err("fio: verify failed at %llu/%u\n",
-                                       io_u->offset + hdr_num * hdr->len,
-                                       hdr->len);
                        continue;
                }
 
@@ -578,6 +570,9 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u)
                }
        }
 
+       if (ret && td->o.verify_fatal)
+               td->terminate = 1;
+
        return ret;
 }
 
@@ -691,7 +686,7 @@ void populate_verify_io_u(struct thread_data *td, struct io_u *io_u)
        if (td->o.verify == VERIFY_NULL)
                return;
 
-       fill_pattern(td, p, io_u->buflen);
+       fill_pattern(td, p, io_u->buflen, io_u);
 
        hdr_inc = io_u->buflen;
        if (td->o.verify_interval)
@@ -875,7 +870,8 @@ static void *verify_async_thread(void *data)
 
        if (ret) {
                td_verror(td, ret, "async_verify");
-               td->terminate = 1;
+               if (td->o.verify_fatal)
+                       td->terminate = 1;
        }
 
 done:
@@ -890,12 +886,16 @@ done:
 int verify_async_init(struct thread_data *td)
 {
        int i, ret;
+       pthread_attr_t attr;
+
+       pthread_attr_init(&attr);
+       pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
 
        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,
+               ret = pthread_create(&td->verify_threads[i], &attr,
                                        verify_async_thread, td);
                if (ret) {
                        log_err("fio: async verify creation failed: %s\n",
@@ -911,6 +911,8 @@ int verify_async_init(struct thread_data *td)
                td->nr_verify_threads++;
        }
 
+       pthread_attr_destroy(&attr);
+
        if (i != td->o.verify_async) {
                log_err("fio: only %d verify threads started, exiting\n", i);
                td->verify_thread_exit = 1;