t/io_uring: print file depths

[fio.git] / zbd.c

diff --git a/zbd.c b/zbd.c
index 9c3092ab2424dae64c6f19646ff8ae85cbda9515..8acda1f62f32bcf38c458f3eb67110e54262da7c 100644 (file)
--- a/zbd.c
+++ b/zbd.c
@@ -606,7 +606,7 @@ static int zbd_reset_range(struct thread_data *td, const struct fio_file *f,
 static unsigned int zbd_zone_nr(struct zoned_block_device_info *zbd_info,
                                struct fio_zone_info *zone)
 {
-       return (uintptr_t) zone - (uintptr_t) zbd_info->zone_info;
+       return zone - zbd_info->zone_info;
 }
 
 /**
@@ -620,12 +620,10 @@ static unsigned int zbd_zone_nr(struct zoned_block_device_info *zbd_info,
 static int zbd_reset_zone(struct thread_data *td, const struct fio_file *f,
                          struct fio_zone_info *z)
 {
-       int ret;
-
        dprint(FD_ZBD, "%s: resetting wp of zone %u.\n", f->file_name,
                zbd_zone_nr(f->zbd_info, z));
-       ret = zbd_reset_range(td, f, z->start, (z+1)->start - z->start);
-       return ret;
+
+       return zbd_reset_range(td, f, z->start, (z+1)->start - z->start);
 }
 
 /*
@@ -728,34 +726,68 @@ static bool zbd_dec_and_reset_write_cnt(const struct thread_data *td,
        return write_cnt == 0;
 }
 
-/* Check whether the value of zbd_info.sectors_with_data is correct. */
-static void check_swd(const struct thread_data *td, const struct fio_file *f)
+enum swd_action {
+       CHECK_SWD,
+       SET_SWD,
+};
+
+/* Calculate the number of sectors with data (swd) and perform action 'a' */
+static uint64_t zbd_process_swd(const struct fio_file *f, enum swd_action a)
 {
-#if 0
        struct fio_zone_info *zb, *ze, *z;
-       uint64_t swd;
+       uint64_t swd = 0;
 
        zb = &f->zbd_info->zone_info[zbd_zone_idx(f, f->file_offset)];
        ze = &f->zbd_info->zone_info[zbd_zone_idx(f, f->file_offset +
                                                  f->io_size)];
-       swd = 0;
        for (z = zb; z < ze; z++) {
                pthread_mutex_lock(&z->mutex);
                swd += z->wp - z->start;
        }
        pthread_mutex_lock(&f->zbd_info->mutex);
-       assert(f->zbd_info->sectors_with_data == swd);
+       switch (a) {
+       case CHECK_SWD:
+               assert(f->zbd_info->sectors_with_data == swd);
+               break;
+       case SET_SWD:
+               f->zbd_info->sectors_with_data = swd;
+               break;
+       }
        pthread_mutex_unlock(&f->zbd_info->mutex);
        for (z = zb; z < ze; z++)
                pthread_mutex_unlock(&z->mutex);
-#endif
+
+       return swd;
+}
+
+/*
+ * The swd check is useful for debugging but takes too much time to leave
+ * it enabled all the time. Hence it is disabled by default.
+ */
+static const bool enable_check_swd = false;
+
+/* Check whether the value of zbd_info.sectors_with_data is correct. */
+static void zbd_check_swd(const struct fio_file *f)
+{
+       if (!enable_check_swd)
+               return;
+
+       zbd_process_swd(f, CHECK_SWD);
+}
+
+static void zbd_init_swd(struct fio_file *f)
+{
+       uint64_t swd;
+
+       swd = zbd_process_swd(f, SET_SWD);
+       dprint(FD_ZBD, "%s(%s): swd = %" PRIu64 "\n", __func__, f->file_name,
+              swd);
 }
 
 void zbd_file_reset(struct thread_data *td, struct fio_file *f)
 {
-       struct fio_zone_info *zb, *ze, *z;
+       struct fio_zone_info *zb, *ze;
        uint32_t zone_idx_e;
-       uint64_t swd = 0;
 
        if (!f->zbd_info)
                return;
@@ -763,17 +795,7 @@ void zbd_file_reset(struct thread_data *td, struct fio_file *f)
        zb = &f->zbd_info->zone_info[zbd_zone_idx(f, f->file_offset)];
        zone_idx_e = zbd_zone_idx(f, f->file_offset + f->io_size);
        ze = &f->zbd_info->zone_info[zone_idx_e];
-       for (z = zb ; z < ze; z++) {
-               pthread_mutex_lock(&z->mutex);
-               swd += z->wp - z->start;
-       }
-       pthread_mutex_lock(&f->zbd_info->mutex);
-       f->zbd_info->sectors_with_data = swd;
-       pthread_mutex_unlock(&f->zbd_info->mutex);
-       for (z = zb ; z < ze; z++)
-               pthread_mutex_unlock(&z->mutex);
-       dprint(FD_ZBD, "%s(%s): swd = %llu\n", __func__, f->file_name,
-               (unsigned long long) swd);
+       zbd_init_swd(f);
        /*
         * If data verification is enabled reset the affected zones before
         * writing any data to avoid that a zone reset has to be issued while
@@ -1102,6 +1124,8 @@ static void zbd_post_submit(const struct io_u *io_u, bool success)
        }
 unlock:
        pthread_mutex_unlock(&z->mutex);
+
+       zbd_check_swd(io_u->file);
 }
 
 bool zbd_unaligned_write(int error_code)
@@ -1154,6 +1178,8 @@ enum io_u_action zbd_adjust_block(struct thread_data *td, struct io_u *io_u)
            io_u->ddir == DDIR_READ && td->o.read_beyond_wp)
                return io_u_accept;
 
+       zbd_check_swd(f);
+
        pthread_mutex_lock(&zb->mutex);
        switch (io_u->ddir) {
        case DDIR_READ:
@@ -1227,7 +1253,6 @@ enum io_u_action zbd_adjust_block(struct thread_data *td, struct io_u *io_u)
                }
                /* Check whether the zone reset threshold has been exceeded */
                if (td->o.zrf.u.f) {
-                       check_swd(td, f);
                        if (f->zbd_info->sectors_with_data >=
                            f->io_size * td->o.zrt.u.f &&
                            zbd_dec_and_reset_write_cnt(td, f)) {
@@ -1248,7 +1273,6 @@ enum io_u_action zbd_adjust_block(struct thread_data *td, struct io_u *io_u)
                        zb->reset_zone = 0;
                        if (zbd_reset_zone(td, f, zb) < 0)
                                goto eof;
-                       check_swd(td, f);
                }
                /* Make writes occur at the write pointer */
                assert(!zbd_zone_full(f, zb, min_bs));