Ensure that set_name_idx() doesn't exceed target bounds

[fio.git] / verify.c

diff --git a/verify.c b/verify.c
index c2b3c40edef83619b4937a8de058915a6e8e5192..aa178e950b83bf43757b707c6e4b681ff08d015d 100644 (file)
--- a/verify.c
+++ b/verify.c
@@ -29,62 +29,47 @@ static void populate_hdr(struct thread_data *td, struct io_u *io_u,
                         struct verify_header *hdr, unsigned int header_num,
                         unsigned int header_len);
 
-static void fill_pattern(void *p, unsigned int len, char *pattern,
-                        unsigned int pattern_bytes)
+void fill_buffer_pattern(struct thread_data *td, void *p, unsigned int len)
 {
-       switch (pattern_bytes) {
-       case 0:
-               assert(0);
-               break;
-       case 1:
-               dprint(FD_VERIFY, "fill verify pattern b=0 len=%u\n", len);
-               memset(p, pattern[0], len);
-               break;
-       default: {
-               unsigned int i = 0, size = 0;
-               unsigned char *b = p;
-
-               dprint(FD_VERIFY, "fill verify pattern b=%d len=%u\n",
-                                       pattern_bytes, len);
-
-               while (i < len) {
-                       size = pattern_bytes;
-                       if (size > (len - i))
-                               size = len - i;
-                       memcpy(b+i, pattern, size);
-                       i += size;
-               }
-               break;
-               }
-       }
+       fill_pattern(p, len, td->o.buffer_pattern, td->o.buffer_pattern_bytes);
 }
 
-void fill_buffer_pattern(struct thread_data *td, void *p, unsigned int len)
+void __fill_buffer(struct thread_options *o, unsigned long seed, void *p,
+                  unsigned int len)
 {
-       fill_pattern(p, len, td->o.buffer_pattern, td->o.buffer_pattern_bytes);
+       __fill_random_buf_percentage(seed, p, o->compress_percentage, len, len, o->buffer_pattern, o->buffer_pattern_bytes);
+}
+
+unsigned long fill_buffer(struct thread_data *td, void *p, unsigned int len)
+{
+       struct frand_state *fs = &td->verify_state;
+       struct thread_options *o = &td->o;
+
+       return fill_random_buf_percentage(fs, p, o->compress_percentage, len, len, o->buffer_pattern, o->buffer_pattern_bytes);
 }
 
 void fill_verify_pattern(struct thread_data *td, void *p, unsigned int len,
                         struct io_u *io_u, unsigned long seed, int use_seed)
 {
-       if (!td->o.verify_pattern_bytes) {
+       struct thread_options *o = &td->o;
+
+       if (!o->verify_pattern_bytes) {
                dprint(FD_VERIFY, "fill random bytes len=%u\n", len);
 
                if (use_seed)
-                       __fill_random_buf(p, len, seed);
+                       __fill_buffer(o, seed, p, len);
                else
-                       io_u->rand_seed = fill_random_buf(&td->verify_state, p, len);
+                       io_u->rand_seed = fill_buffer(td, p, len);
                return;
        }
 
        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);
+                       o->verify_pattern_bytes, len);
                return;
        }
 
-       fill_pattern(p, len, td->o.verify_pattern, td->o.verify_pattern_bytes);
-
+       fill_pattern(p, len, o->verify_pattern, o->verify_pattern_bytes);
        io_u->buf_filled_len = len;
 }
 
@@ -487,6 +472,7 @@ static int verify_io_u_sha256(struct verify_header *hdr, struct vcont *vc)
 
        fio_sha256_init(&sha256_ctx);
        fio_sha256_update(&sha256_ctx, p, hdr->len - hdr_size(hdr));
+       fio_sha256_final(&sha256_ctx);
 
        if (!memcmp(vh->sha256, sha256_ctx.buf, sizeof(sha256)))
                return 0;
@@ -512,6 +498,7 @@ static int verify_io_u_sha1(struct verify_header *hdr, struct vcont *vc)
 
        fio_sha1_init(&sha1_ctx);
        fio_sha1_update(&sha1_ctx, p, hdr->len - hdr_size(hdr));
+       fio_sha1_final(&sha1_ctx);
 
        if (!memcmp(vh->sha1, sha1_ctx.H, sizeof(sha1)))
                return 0;
@@ -642,6 +629,7 @@ static int verify_io_u_md5(struct verify_header *hdr, struct vcont *vc)
 
        fio_md5_init(&md5_ctx);
        fio_md5_update(&md5_ctx, p, hdr->len - hdr_size(hdr));
+       fio_md5_final(&md5_ctx);
 
        if (!memcmp(vh->md5_digest, md5_ctx.hash, sizeof(hash)))
                return 0;
@@ -668,7 +656,7 @@ int verify_io_u_async(struct thread_data *td, struct io_u **io_u_ptr)
 
        if (io_u->flags & IO_U_F_IN_CUR_DEPTH) {
                td->cur_depth--;
-               io_u->flags &= ~IO_U_F_IN_CUR_DEPTH;
+               io_u_clear(io_u, IO_U_F_IN_CUR_DEPTH);
        }
        flist_add_tail(&io_u->verify_list, &td->verify_list);
        *io_u_ptr = NULL;
@@ -908,6 +896,7 @@ static void fill_sha256(struct verify_header *hdr, void *p, unsigned int len)
 
        fio_sha256_init(&sha256_ctx);
        fio_sha256_update(&sha256_ctx, p, len);
+       fio_sha256_final(&sha256_ctx);
 }
 
 static void fill_sha1(struct verify_header *hdr, void *p, unsigned int len)
@@ -919,6 +908,7 @@ static void fill_sha1(struct verify_header *hdr, void *p, unsigned int len)
 
        fio_sha1_init(&sha1_ctx);
        fio_sha1_update(&sha1_ctx, p, len);
+       fio_sha1_final(&sha1_ctx);
 }
 
 static void fill_crc7(struct verify_header *hdr, void *p, unsigned int len)
@@ -965,6 +955,7 @@ static void fill_md5(struct verify_header *hdr, void *p, unsigned int len)
 
        fio_md5_init(&md5_ctx);
        fio_md5_update(&md5_ctx, p, len);
+       fio_md5_final(&md5_ctx);
 }
 
 static void populate_hdr(struct thread_data *td, struct io_u *io_u,
@@ -1114,10 +1105,10 @@ int get_next_verify(struct thread_data *td, struct io_u *io_u)
                io_u->buflen = ipo->len;
                io_u->numberio = ipo->numberio;
                io_u->file = ipo->file;
-               io_u->flags |= IO_U_F_VER_LIST;
+               io_u_set(io_u, IO_U_F_VER_LIST);
 
                if (ipo->flags & IP_F_TRIMMED)
-                       io_u->flags |= IO_U_F_TRIMMED;
+                       io_u_set(io_u, IO_U_F_TRIMMED);
 
                if (!fio_file_open(io_u->file)) {
                        int r = td_io_open_file(td, io_u->file);
@@ -1166,7 +1157,7 @@ static void *verify_async_thread(void *data)
        struct io_u *io_u;
        int ret = 0;
 
-       if (td->o.verify_cpumask_set &&
+       if (fio_option_is_set(&td->o, verify_cpumask) &&
            fio_setaffinity(td->pid, td->o.verify_cpumask)) {
                log_err("fio: failed setting verify thread affinity\n");
                goto done;
@@ -1201,7 +1192,7 @@ static void *verify_async_thread(void *data)
                        io_u = flist_first_entry(&list, struct io_u, verify_list);
                        flist_del_init(&io_u->verify_list);
 
-                       io_u->flags |= IO_U_F_NO_FILE_PUT;
+                       io_u_set(io_u, IO_U_F_NO_FILE_PUT);
                        ret = verify_io_u(td, &io_u);
 
                        put_io_u(td, io_u);
@@ -1356,7 +1347,8 @@ struct all_io_list *get_all_io_list(int save_mask, size_t *sz)
                s->rand.s[1] = cpu_to_le32(td->random_state.s2);
                s->rand.s[2] = cpu_to_le32(td->random_state.s3);
                s->rand.s[3] = 0;
-               strncpy((char *) s->name, td->o.name, sizeof(s->name));
+               s->name[sizeof(s->name) - 1] = '\0';
+               strncpy((char *) s->name, td->o.name, sizeof(s->name) - 1);
                next = io_list_next(s);
        }
 
@@ -1554,10 +1546,12 @@ int verify_state_should_stop(struct thread_data *td, struct io_u *io_u)
                return 0;
 
        /*
-        * If we're not into the window of issues - depth yet, continue
+        * If we're not into the window of issues - depth yet, continue. If
+        * issue is shorter than depth, do check.
         */
-       if (td->io_blocks[DDIR_READ] < s->depth ||
-           s->numberio - td->io_blocks[DDIR_READ] > s->depth)
+       if ((td->io_blocks[DDIR_READ] < s->depth ||
+           s->numberio - td->io_blocks[DDIR_READ] > s->depth) &&
+           s->numberio > s->depth)
                return 0;
 
        /*