fio: use LDFLAGS when linking dynamic engines

[fio.git] / zbd.c

diff --git a/zbd.c b/zbd.c
index b917fa427555e16f3aa875b9f69906a69b99238a..b1fd6b4bb0ae23cda7dba13a3c0bf3577139600f 100644 (file)
--- a/zbd.c
+++ b/zbd.c
@@ -27,19 +27,20 @@ static bool is_valid_offset(const struct fio_file *f, uint64_t offset)
        return (uint64_t)(offset - f->file_offset) < f->io_size;
 }
 
-static inline unsigned int zbd_zone_nr(const struct fio_file *f,
-                                      struct fio_zone_info *zone)
+static inline unsigned int zbd_zone_idx(const struct fio_file *f,
+                                       struct fio_zone_info *zone)
 {
        return zone - f->zbd_info->zone_info;
 }
 
 /**
- * zbd_zone_idx - convert an offset into a zone number
+ * zbd_offset_to_zone_idx - convert an offset into a zone number
  * @f: file pointer.
  * @offset: offset in bytes. If this offset is in the first zone_size bytes
  *         past the disk size then the index of the sentinel is returned.
  */
-static uint32_t zbd_zone_idx(const struct fio_file *f, uint64_t offset)
+static unsigned int zbd_offset_to_zone_idx(const struct fio_file *f,
+                                          uint64_t offset)
 {
        uint32_t zone_idx;
 
@@ -122,10 +123,16 @@ static inline void zone_unlock(struct fio_zone_info *z)
        assert(!ret);
 }
 
-static inline struct fio_zone_info *get_zone(const struct fio_file *f,
-                                            unsigned int zone_nr)
+static inline struct fio_zone_info *zbd_get_zone(const struct fio_file *f,
+                                                unsigned int zone_idx)
 {
-       return &f->zbd_info->zone_info[zone_nr];
+       return &f->zbd_info->zone_info[zone_idx];
+}
+
+static inline struct fio_zone_info *
+zbd_offset_to_zone(const struct fio_file *f,  uint64_t offset)
+{
+       return zbd_get_zone(f, zbd_offset_to_zone_idx(f, offset));
 }
 
 /**
@@ -253,7 +260,7 @@ static int zbd_reset_zone(struct thread_data *td, struct fio_file *f,
        assert(is_valid_offset(f, offset + length - 1));
 
        dprint(FD_ZBD, "%s: resetting wp of zone %u.\n",
-              f->file_name, zbd_zone_nr(f, z));
+              f->file_name, zbd_zone_idx(f, z));
 
        switch (f->zbd_info->model) {
        case ZBD_HOST_AWARE:
@@ -296,14 +303,14 @@ static void zbd_close_zone(struct thread_data *td, const struct fio_file *f,
                return;
 
        for (ozi = 0; ozi < f->zbd_info->num_open_zones; ozi++) {
-               if (get_zone(f, f->zbd_info->open_zones[ozi]) == z)
+               if (zbd_get_zone(f, f->zbd_info->open_zones[ozi]) == z)
                        break;
        }
        if (ozi == f->zbd_info->num_open_zones)
                return;
 
        dprint(FD_ZBD, "%s: closing zone %u\n",
-              f->file_name, zbd_zone_nr(f, z));
+              f->file_name, zbd_zone_idx(f, z));
 
        memmove(f->zbd_info->open_zones + ozi,
                f->zbd_info->open_zones + ozi + 1,
@@ -335,7 +342,7 @@ static int zbd_reset_zones(struct thread_data *td, struct fio_file *f,
        assert(min_bs);
 
        dprint(FD_ZBD, "%s: examining zones %u .. %u\n",
-              f->file_name, zbd_zone_nr(f, zb), zbd_zone_nr(f, ze));
+              f->file_name, zbd_zone_idx(f, zb), zbd_zone_idx(f, ze));
 
        for (z = zb; z < ze; z++) {
                if (!z->has_wp)
@@ -348,7 +355,7 @@ static int zbd_reset_zones(struct thread_data *td, struct fio_file *f,
 
                if (z->wp != z->start) {
                        dprint(FD_ZBD, "%s: resetting zone %u\n",
-                              f->file_name, zbd_zone_nr(f, z));
+                              f->file_name, zbd_zone_idx(f, z));
                        if (zbd_reset_zone(td, f, z) < 0)
                                res = 1;
                }
@@ -404,7 +411,7 @@ static bool zbd_open_zone(struct thread_data *td, const struct fio_file *f,
 {
        const uint64_t min_bs = td->o.min_bs[DDIR_WRITE];
        struct zoned_block_device_info *zbdi = f->zbd_info;
-       uint32_t zone_idx = zbd_zone_nr(f, z);
+       uint32_t zone_idx = zbd_zone_idx(f, z);
        bool res = true;
 
        if (z->cond == ZBD_ZONE_COND_OFFLINE)
@@ -489,10 +496,11 @@ static bool zbd_is_seq_job(struct fio_file *f)
        if (f->io_size == 0)
                return false;
 
-       zone_idx_b = zbd_zone_idx(f, f->file_offset);
-       zone_idx_e = zbd_zone_idx(f, f->file_offset + f->io_size - 1);
+       zone_idx_b = zbd_offset_to_zone_idx(f, f->file_offset);
+       zone_idx_e =
+               zbd_offset_to_zone_idx(f, f->file_offset + f->io_size - 1);
        for (zone_idx = zone_idx_b; zone_idx <= zone_idx_e; zone_idx++)
-               if (get_zone(f, zone_idx)->has_wp)
+               if (zbd_get_zone(f, zone_idx)->has_wp)
                        return true;
 
        return false;
@@ -508,7 +516,6 @@ static bool zbd_zone_align_file_sizes(struct thread_data *td,
 {
        const struct fio_zone_info *z;
        uint64_t new_offset, new_end;
-       uint32_t zone_idx;
 
        if (!f->zbd_info)
                return true;
@@ -538,8 +545,7 @@ static bool zbd_zone_align_file_sizes(struct thread_data *td,
                return false;
        }
 
-       zone_idx = zbd_zone_idx(f, f->file_offset);
-       z = get_zone(f, zone_idx);
+       z = zbd_offset_to_zone(f, f->file_offset);
        if ((f->file_offset != z->start) &&
            (td->o.td_ddir != TD_DDIR_READ)) {
                new_offset = zbd_zone_end(z);
@@ -555,8 +561,7 @@ static bool zbd_zone_align_file_sizes(struct thread_data *td,
                f->file_offset = new_offset;
        }
 
-       zone_idx = zbd_zone_idx(f, f->file_offset + f->io_size);
-       z = get_zone(f, zone_idx);
+       z = zbd_offset_to_zone(f, f->file_offset + f->io_size);
        new_end = z->start;
        if ((td->o.td_ddir != TD_DDIR_READ) &&
            (f->file_offset + f->io_size != new_end)) {
@@ -1046,8 +1051,9 @@ int zbd_setup_files(struct thread_data *td)
 
                assert(zbd);
 
-               f->min_zone = zbd_zone_idx(f, f->file_offset);
-               f->max_zone = zbd_zone_idx(f, f->file_offset + f->io_size);
+               f->min_zone = zbd_offset_to_zone_idx(f, f->file_offset);
+               f->max_zone =
+                       zbd_offset_to_zone_idx(f, f->file_offset + f->io_size);
 
                /*
                 * When all zones in the I/O range are conventional, io_size
@@ -1153,8 +1159,8 @@ static uint64_t zbd_process_swd(struct thread_data *td,
        uint64_t swd = 0;
        uint64_t wp_swd = 0;
 
-       zb = get_zone(f, f->min_zone);
-       ze = get_zone(f, f->max_zone);
+       zb = zbd_get_zone(f, f->min_zone);
+       ze = zbd_get_zone(f, f->max_zone);
        for (z = zb; z < ze; z++) {
                if (z->has_wp) {
                        zone_lock(td, f, z);
@@ -1206,8 +1212,8 @@ void zbd_file_reset(struct thread_data *td, struct fio_file *f)
        if (!f->zbd_info || !td_write(td))
                return;
 
-       zb = get_zone(f, f->min_zone);
-       ze = get_zone(f, f->max_zone);
+       zb = zbd_get_zone(f, f->min_zone);
+       ze = zbd_get_zone(f, f->max_zone);
        swd = zbd_process_swd(td, f, SET_SWD);
 
        dprint(FD_ZBD, "%s(%s): swd = %" PRIu64 "\n",
@@ -1275,7 +1281,7 @@ static struct fio_zone_info *zbd_convert_to_open_zone(struct thread_data *td,
                 */
                zone_idx = zbdi->open_zones[pick_random_zone_idx(f, io_u)];
        } else {
-               zone_idx = zbd_zone_idx(f, io_u->offset);
+               zone_idx = zbd_offset_to_zone_idx(f, io_u->offset);
        }
        if (zone_idx < f->min_zone)
                zone_idx = f->min_zone;
@@ -1295,7 +1301,7 @@ static struct fio_zone_info *zbd_convert_to_open_zone(struct thread_data *td,
        for (;;) {
                uint32_t tmp_idx;
 
-               z = get_zone(f, zone_idx);
+               z = zbd_get_zone(f, zone_idx);
                if (z->has_wp)
                        zone_lock(td, f, z);
 
@@ -1401,7 +1407,7 @@ retry:
                if (!is_valid_offset(f, z->start)) {
                        /* Wrap-around. */
                        zone_idx = f->min_zone;
-                       z = get_zone(f, zone_idx);
+                       z = zbd_get_zone(f, zone_idx);
                }
                assert(is_valid_offset(f, z->start));
                if (!z->has_wp)
@@ -1424,7 +1430,7 @@ retry:
                pthread_mutex_unlock(&zbdi->mutex);
                zone_unlock(z);
 
-               z = get_zone(f, zone_idx);
+               z = zbd_get_zone(f, zone_idx);
 
                zone_lock(td, f, z);
                if (z->wp + min_bs <= zbd_zone_capacity_end(z))
@@ -1519,7 +1525,7 @@ zbd_find_zone(struct thread_data *td, struct io_u *io_u, uint64_t min_bytes,
 {
        struct fio_file *f = io_u->file;
        struct fio_zone_info *z1, *z2;
-       const struct fio_zone_info *const zf = get_zone(f, f->min_zone);
+       const struct fio_zone_info *const zf = zbd_get_zone(f, f->min_zone);
 
        /*
         * Skip to the next non-empty zone in case of sequential I/O and to
@@ -1592,15 +1598,11 @@ static void zbd_queue_io(struct thread_data *td, struct io_u *io_u, int q,
        const struct fio_file *f = io_u->file;
        struct zoned_block_device_info *zbd_info = f->zbd_info;
        struct fio_zone_info *z;
-       uint32_t zone_idx;
        uint64_t zone_end;
 
        assert(zbd_info);
 
-       zone_idx = zbd_zone_idx(f, io_u->offset);
-       assert(zone_idx < zbd_info->nr_zones);
-       z = get_zone(f, zone_idx);
-
+       z = zbd_offset_to_zone(f, io_u->offset);
        assert(z->has_wp);
 
        if (!success)
@@ -1608,7 +1610,7 @@ static void zbd_queue_io(struct thread_data *td, struct io_u *io_u, int q,
 
        dprint(FD_ZBD,
               "%s: queued I/O (%lld, %llu) for zone %u\n",
-              f->file_name, io_u->offset, io_u->buflen, zone_idx);
+              f->file_name, io_u->offset, io_u->buflen, zbd_zone_idx(f, z));
 
        switch (io_u->ddir) {
        case DDIR_WRITE:
@@ -1651,19 +1653,15 @@ static void zbd_put_io(struct thread_data *td, const struct io_u *io_u)
        const struct fio_file *f = io_u->file;
        struct zoned_block_device_info *zbd_info = f->zbd_info;
        struct fio_zone_info *z;
-       uint32_t zone_idx;
 
        assert(zbd_info);
 
-       zone_idx = zbd_zone_idx(f, io_u->offset);
-       assert(zone_idx < zbd_info->nr_zones);
-       z = get_zone(f, zone_idx);
-
+       z = zbd_offset_to_zone(f, io_u->offset);
        assert(z->has_wp);
 
        dprint(FD_ZBD,
               "%s: terminate I/O (%lld, %llu) for zone %u\n",
-              f->file_name, io_u->offset, io_u->buflen, zone_idx);
+              f->file_name, io_u->offset, io_u->buflen, zbd_zone_idx(f, z));
 
        zbd_end_zone_io(td, io_u, z);
 
@@ -1705,14 +1703,12 @@ void setup_zbd_zone_mode(struct thread_data *td, struct io_u *io_u)
        struct fio_file *f = io_u->file;
        enum fio_ddir ddir = io_u->ddir;
        struct fio_zone_info *z;
-       uint32_t zone_idx;
 
        assert(td->o.zone_mode == ZONE_MODE_ZBD);
        assert(td->o.zone_size);
        assert(f->zbd_info);
 
-       zone_idx = zbd_zone_idx(f, f->last_pos[ddir]);
-       z = get_zone(f, zone_idx);
+       z = zbd_offset_to_zone(f, f->last_pos[ddir]);
 
        /*
         * When the zone capacity is smaller than the zone size and the I/O is
@@ -1726,7 +1722,7 @@ void setup_zbd_zone_mode(struct thread_data *td, struct io_u *io_u)
                       "%s: Jump from zone capacity limit to zone end:"
                       " (%"PRIu64" -> %"PRIu64") for zone %u (%"PRIu64")\n",
                       f->file_name, f->last_pos[ddir],
-                      zbd_zone_end(z), zone_idx, z->capacity);
+                      zbd_zone_end(z), zbd_zone_idx(f, z), z->capacity);
                td->io_skip_bytes += zbd_zone_end(z) - f->last_pos[ddir];
                f->last_pos[ddir] = zbd_zone_end(z);
        }
@@ -1807,7 +1803,6 @@ enum io_u_action zbd_adjust_block(struct thread_data *td, struct io_u *io_u)
 {
        struct fio_file *f = io_u->file;
        struct zoned_block_device_info *zbdi = f->zbd_info;
-       uint32_t zone_idx_b;
        struct fio_zone_info *zb, *zl, *orig_zb;
        uint32_t orig_len = io_u->buflen;
        uint64_t min_bs = td->o.min_bs[io_u->ddir];
@@ -1819,8 +1814,7 @@ enum io_u_action zbd_adjust_block(struct thread_data *td, struct io_u *io_u)
        assert(is_valid_offset(f, io_u->offset));
        assert(io_u->buflen);
 
-       zone_idx_b = zbd_zone_idx(f, io_u->offset);
-       zb = get_zone(f, zone_idx_b);
+       zb = zbd_offset_to_zone(f, io_u->offset);
        orig_zb = zb;
 
        if (!zb->has_wp) {
@@ -1883,7 +1877,7 @@ enum io_u_action zbd_adjust_block(struct thread_data *td, struct io_u *io_u)
                if (range < min_bs ||
                    ((!td_random(td)) && (io_u->offset + min_bs > zb->wp))) {
                        zone_unlock(zb);
-                       zl = get_zone(f, f->max_zone);
+                       zl = zbd_get_zone(f, f->max_zone);
                        zb = zbd_find_zone(td, io_u, min_bs, zb, zl);
                        if (!zb) {
                                dprint(FD_ZBD,
@@ -2027,7 +2021,7 @@ enum io_u_action zbd_adjust_block(struct thread_data *td, struct io_u *io_u)
 
                /* Find out a non-empty zone to trim */
                zone_unlock(zb);
-               zl = get_zone(f, f->max_zone);
+               zl = zbd_get_zone(f, f->max_zone);
                zb = zbd_find_zone(td, io_u, 1, zb, zl);
                if (zb) {
                        io_u->offset = zb->start;
@@ -2099,12 +2093,9 @@ int zbd_do_io_u_trim(const struct thread_data *td, struct io_u *io_u)
 {
        struct fio_file *f = io_u->file;
        struct fio_zone_info *z;
-       uint32_t zone_idx;
        int ret;
 
-       zone_idx = zbd_zone_idx(f, io_u->offset);
-       z = get_zone(f, zone_idx);
-
+       z = zbd_offset_to_zone(f, io_u->offset);
        if (!z->has_wp)
                return 0;